@dlh.io/bideux 0.1.0

package/dist/chunk-OMPR32AR.js

@@ -0,0 +1,1320 @@
+import { isRecord, record, displayBlock, stringValue, rendererFrame } from './chunk-75CRTQK7.js';
+import { format, addDays, subDays } from 'date-fns';
+
+var AGGREGATE_FUNCTIONS = /* @__PURE__ */ new Set([
+  "min",
+  "max",
+  "median",
+  "avg",
+  "sum",
+  "count",
+  "first",
+  "last"
+]);
+var MATH_FUNCTIONS = {
+  abs: (v) => Math.abs(toNumber(v)),
+  round: (v) => Math.round(toNumber(v)),
+  floor: (v) => Math.floor(toNumber(v)),
+  ceil: (v) => Math.ceil(toNumber(v)),
+  float: (v) => Number(v),
+  int: (v) => Math.trunc(toNumber(v)),
+  len: (v) => Array.isArray(v) ? v.length : String(v).length,
+  today: (fmt) => format(/* @__PURE__ */ new Date(), typeof fmt === "string" && fmt ? fmt : "yyyy-MM-dd"),
+  yesterday: (fmt) => format(
+    subDays(/* @__PURE__ */ new Date(), 1),
+    typeof fmt === "string" && fmt ? fmt : "yyyy-MM-dd"
+  ),
+  tomorrow: (fmt) => format(
+    addDays(/* @__PURE__ */ new Date(), 1),
+    typeof fmt === "string" && fmt ? fmt : "yyyy-MM-dd"
+  ),
+  now: () => (/* @__PURE__ */ new Date()).toISOString()
+};
+function tokenize(input) {
+  const tokens = [];
+  const regex = /\s*(\d+(?:\.\d+)?(?:[eE][+-]?\d+)?|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\$\{[A-Za-z_][A-Za-z0-9_]*\}|&&|\|\||==|!=|<=|>=|\*\*|[+\-*/%<>,!():.[\]{}]|[A-Za-z_][A-Za-z0-9_]*)\s*/y;
+  while (regex.lastIndex < input.length) {
+    const match = regex.exec(input);
+    if (!match) {
+      throw new Error(`Unexpected character at position ${regex.lastIndex}`);
+    }
+    const captured = match[1];
+    if (captured === void 0) {
+      throw new Error(`Unexpected character at position ${regex.lastIndex}`);
+    }
+    let value = captured;
+    let type;
+    let raw = value;
+    if (/^\$\{/.test(value)) {
+      type = "variable";
+      value = value.slice(2, -1);
+      raw = value;
+    } else if (/^\d/.test(value)) {
+      type = "number";
+      raw = Number(value);
+    } else if (value === "true" || value === "false") {
+      type = "boolean";
+      raw = value === "true";
+    } else if (value === "null") {
+      type = "null";
+      raw = null;
+    } else if (/^"|'/.test(value)) {
+      type = "string";
+      raw = value.slice(1, -1).replace(/\\(.)/g, (_, ch) => {
+        switch (ch) {
+          case "n":
+            return "\n";
+          case "t":
+            return "	";
+          case "r":
+            return "\r";
+          default:
+            return ch;
+        }
+      });
+    } else if (/^[A-Za-z_]/.test(value)) {
+      type = "identifier";
+    } else if (/^[+\-*/%<>=!&|*]+$/.test(value)) {
+      type = "operator";
+    } else {
+      type = "punct";
+    }
+    tokens.push({ type, value, raw });
+  }
+  return tokens;
+}
+var Parser = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  pos = 0;
+  parse() {
+    const node = this.logicalOr();
+    if (this.pos < this.tokens.length) {
+      const token = this.current();
+      if (token === void 0) {
+        throw new Error("Unexpected end of expression");
+      }
+      throw new Error(
+        `Unexpected token '${token.value}' at position ${this.pos}`
+      );
+    }
+    return node;
+  }
+  current() {
+    return this.tokens[this.pos];
+  }
+  peek(offset = 0) {
+    return this.tokens[this.pos + offset];
+  }
+  eat(value) {
+    if (this.current()?.value !== value) {
+      throw new Error(
+        `Expected '${value}' but got '${this.current()?.value ?? "EOF"}'`
+      );
+    }
+    this.pos++;
+  }
+  matchOperator(...ops) {
+    const token = this.current();
+    if (token?.type === "operator" && ops.includes(token.value)) {
+      this.pos++;
+      return true;
+    }
+    return false;
+  }
+  previousOperator(fallback) {
+    return this.tokens[this.pos - 1]?.value ?? fallback;
+  }
+  logicalOr() {
+    let left = this.logicalAnd();
+    while (this.matchOperator("||")) {
+      const right = this.logicalAnd();
+      left = { kind: "binary", op: "||", left, right };
+    }
+    return left;
+  }
+  logicalAnd() {
+    let left = this.equality();
+    while (this.matchOperator("&&")) {
+      const right = this.equality();
+      left = { kind: "binary", op: "&&", left, right };
+    }
+    return left;
+  }
+  equality() {
+    let left = this.comparison();
+    while (this.matchOperator("==", "!=")) {
+      const op = this.previousOperator("==");
+      const right = this.comparison();
+      left = { kind: "binary", op, left, right };
+    }
+    return left;
+  }
+  comparison() {
+    let left = this.additive();
+    while (this.matchOperator("<", "<=", ">", ">=")) {
+      const op = this.previousOperator("<");
+      const right = this.additive();
+      left = { kind: "binary", op, left, right };
+    }
+    return left;
+  }
+  additive() {
+    let left = this.multiplicative();
+    while (this.matchOperator("+", "-")) {
+      const op = this.previousOperator("+");
+      const right = this.multiplicative();
+      left = { kind: "binary", op, left, right };
+    }
+    return left;
+  }
+  multiplicative() {
+    let left = this.power();
+    while (this.matchOperator("*", "/", "%")) {
+      const op = this.previousOperator("*");
+      const right = this.power();
+      left = { kind: "binary", op, left, right };
+    }
+    return left;
+  }
+  power() {
+    let left = this.unary();
+    while (this.matchOperator("**")) {
+      const right = this.unary();
+      left = { kind: "binary", op: "**", left, right };
+    }
+    return left;
+  }
+  unary() {
+    if (this.matchOperator("+", "-", "!")) {
+      const token = this.tokens[this.pos - 1];
+      if (token === void 0) {
+        throw new Error("Unexpected end of expression");
+      }
+      const op = token.value;
+      const right = this.unary();
+      return { kind: "unary", op, right };
+    }
+    return this.primary();
+  }
+  primary() {
+    const token = this.current();
+    if (!token) throw new Error("Unexpected end of expression");
+    if (token.type === "number") {
+      this.pos++;
+      return { kind: "number", value: Number(token.raw) };
+    }
+    if (token.type === "variable") {
+      this.pos++;
+      return { kind: "variable", name: token.value };
+    }
+    if (token.type === "string") {
+      this.pos++;
+      return { kind: "string", value: String(token.raw) };
+    }
+    if (token.type === "boolean") {
+      this.pos++;
+      return { kind: "boolean", value: Boolean(token.raw) };
+    }
+    if (token.type === "null") {
+      this.pos++;
+      return { kind: "null" };
+    }
+    if (token.type === "identifier") {
+      this.pos++;
+      const name = token.value;
+      if (this.current()?.value === "(") {
+        this.eat("(");
+        const args = [];
+        if (this.current()?.value !== ")") {
+          args.push(this.logicalOr());
+          while (this.current()?.value === ",") {
+            this.eat(",");
+            args.push(this.logicalOr());
+          }
+        }
+        this.eat(")");
+        return { kind: "call", name, args };
+      }
+      if (this.current()?.value === "." && (name === "rows" || name === "row")) {
+        this.eat(".");
+        const fieldToken = this.current();
+        if (fieldToken?.type !== "identifier") {
+          throw new Error(`Expected field name after '${name}.'`);
+        }
+        this.pos++;
+        if (name === "row") {
+          return { kind: "rowField", name: fieldToken.value };
+        }
+        return { kind: "rowsField", name: fieldToken.value };
+      }
+      return { kind: "identifier", name };
+    }
+    if (token.value === "(") {
+      this.eat("(");
+      const node = this.logicalOr();
+      this.eat(")");
+      return node;
+    }
+    throw new Error(`Unexpected token '${token.value}'`);
+  }
+};
+function toNumber(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "boolean") return value ? 1 : 0;
+  if (value === null || value === void 0) return 0;
+  const parsed = Number(value);
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+function toString(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") return value;
+  return String(value);
+}
+function isTruthy(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  if (typeof value === "string") return value.length > 0;
+  if (Array.isArray(value)) return value.length > 0;
+  return value !== null && value !== void 0;
+}
+function compareEqual(left, right) {
+  if (left === null || left === void 0)
+    return right === null || right === void 0;
+  if (right === null || right === void 0) return false;
+  if (typeof left === "number" && typeof right === "number")
+    return left === right;
+  return String(left) === String(right);
+}
+function evaluateNode(node, context) {
+  switch (node.kind) {
+    case "number":
+      return node.value;
+    case "string":
+      return node.value;
+    case "boolean":
+      return node.value;
+    case "null":
+      return null;
+    case "variable": {
+      const variables = context.variables ?? {};
+      if (node.name in variables) return variables[node.name];
+      throw new Error(`Unknown variable '${node.name}'`);
+    }
+    case "identifier": {
+      const variables = context.variables ?? {};
+      if (node.name in variables) return variables[node.name];
+      if (context.row && node.name in context.row)
+        return context.row[node.name];
+      if (context.rows && context.rows.length > 0) {
+        const sample = context.rows[0];
+        if (sample !== void 0 && node.name in sample) {
+          return context.row?.[node.name];
+        }
+      }
+      throw new Error(`Unknown identifier '${node.name}'`);
+    }
+    case "rowField":
+      if (!context.row)
+        throw new Error("'row.field' is only valid inside a filter context");
+      return context.row[node.name];
+    case "rowsField": {
+      const rows = context.rows ?? [];
+      return rows.map((row) => row[node.name]);
+    }
+    case "call": {
+      const argValues = node.args.map((arg) => evaluateNode(arg, context));
+      if (AGGREGATE_FUNCTIONS.has(node.name)) {
+        return evaluateAggregate(node.name, argValues);
+      }
+      const fn = MATH_FUNCTIONS[node.name];
+      if (fn) return fn(argValues[0]);
+      throw new Error(`Unknown function '${node.name}'`);
+    }
+    case "unary": {
+      const right = evaluateNode(node.right, context);
+      if (node.op === "!") return !isTruthy(right);
+      const num = toNumber(right);
+      return node.op === "-" ? -num : num;
+    }
+    case "binary": {
+      const left = evaluateNode(node.left, context);
+      const right = evaluateNode(node.right, context);
+      switch (node.op) {
+        case "||":
+          return isTruthy(left) || isTruthy(right);
+        case "&&":
+          return isTruthy(left) && isTruthy(right);
+        case "==":
+          return compareEqual(left, right);
+        case "!=":
+          return !compareEqual(left, right);
+        case "<":
+          return toNumber(left) < toNumber(right);
+        case "<=":
+          return toNumber(left) <= toNumber(right);
+        case ">":
+          return toNumber(left) > toNumber(right);
+        case ">=":
+          return toNumber(left) >= toNumber(right);
+        case "+":
+          if (typeof left === "string" || typeof right === "string") {
+            return toString(left) + toString(right);
+          }
+          return toNumber(left) + toNumber(right);
+        case "-":
+          return toNumber(left) - toNumber(right);
+        case "*":
+          return toNumber(left) * toNumber(right);
+        case "/": {
+          const divisor = toNumber(right);
+          return divisor === 0 ? 0 : toNumber(left) / divisor;
+        }
+        case "%": {
+          const mod = toNumber(right);
+          return mod === 0 ? 0 : toNumber(left) % mod;
+        }
+        case "**":
+          return toNumber(left) ** toNumber(right);
+        default:
+          throw new Error(`Unknown operator '${node.op}'`);
+      }
+    }
+    default:
+      throw new Error("Unknown expression node");
+  }
+}
+function evaluateAggregate(name, args) {
+  if (args.length === 0) return null;
+  const values = args[0];
+  if (!Array.isArray(values)) {
+    throw new Error(`Aggregate '${name}' requires a row vector argument`);
+  }
+  const numeric = values.map(
+    (v) => v === null || v === void 0 ? NaN : Number(v)
+  );
+  const finite = numeric.filter((n) => Number.isFinite(n));
+  switch (name) {
+    case "min":
+      return finite.length ? Math.min(...finite) : null;
+    case "max":
+      return finite.length ? Math.max(...finite) : null;
+    case "sum":
+      return finite.reduce((a, b) => a + b, 0);
+    case "avg":
+      return finite.length ? finite.reduce((a, b) => a + b, 0) / finite.length : null;
+    case "count":
+      return values.filter((v) => v !== null && v !== void 0 && v !== "").length;
+    case "first":
+      return values[0] ?? null;
+    case "last":
+      return values[values.length - 1] ?? null;
+    case "median": {
+      if (!finite.length) return null;
+      const sorted = [...finite].sort((a, b) => a - b);
+      const mid = Math.floor(sorted.length / 2);
+      if (sorted.length % 2) return sorted[mid];
+      const lower = sorted[mid - 1];
+      const upper = sorted[mid];
+      if (lower === void 0 || upper === void 0) return null;
+      return (lower + upper) / 2;
+    }
+    default:
+      throw new Error(`Unknown aggregate '${name}'`);
+  }
+}
+function interpolateTemplate(template, variables) {
+  return template.replace(/\$\{([^}]+)\}/g, (_, name) => {
+    if (!(name in variables)) throw new Error(`Unknown variable '${name}'`);
+    const value = variables[name];
+    return value === null || value === void 0 ? "" : String(value);
+  });
+}
+function interpolateVariables(value, variables) {
+  if (typeof value === "string") {
+    if (!value.includes("${")) return value;
+    const interpolated = interpolateTemplate(value, variables);
+    if (/^\$\{[^}]+\}$/.test(value)) {
+      const name = value.slice(2, -1);
+      const raw = variables[name];
+      if (typeof raw === "number" || typeof raw === "boolean" || raw === null) {
+        return raw;
+      }
+    }
+    if (/^-?\d+(\.\d+)?$/.test(interpolated) && !Number.isNaN(Number(interpolated))) {
+      return Number(interpolated);
+    }
+    return interpolated;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => interpolateVariables(item, variables));
+  }
+  if (value !== null && typeof value === "object") {
+    const record2 = value;
+    return Object.fromEntries(
+      Object.entries(record2).map(([k, v]) => [
+        k,
+        interpolateVariables(v, variables)
+      ])
+    );
+  }
+  return value;
+}
+function evaluateExpression(expression, context) {
+  const tokens = tokenize(expression);
+  const parser = new Parser(tokens);
+  const node = parser.parse();
+  return evaluateNode(node, context);
+}
+function evaluateVariables(variables, rows, existingVariables) {
+  if (!variables) return {};
+  const result = { ...existingVariables ?? {} };
+  for (const [name, expression] of Object.entries(variables)) {
+    result[name] = evaluateExpression(expression, { rows, variables: result });
+  }
+  return result;
+}
+function applyFilter(filter, rows, variables) {
+  if (!filter) return rows;
+  return rows.filter(
+    (row) => isTruthy(evaluateExpression(filter, { rows, row, variables }))
+  );
+}
+function dateBuiltinVariables() {
+  const today = /* @__PURE__ */ new Date();
+  return {
+    today: format(today, "yyyy-MM-dd"),
+    yesterday: format(subDays(today, 1), "yyyy-MM-dd"),
+    tomorrow: format(addDays(today, 1), "yyyy-MM-dd"),
+    now: today.toISOString()
+  };
+}
+function resolveFilterDefault(defaultValue, extraVariables) {
+  if (defaultValue === void 0 || defaultValue === null) return "";
+  if (typeof defaultValue !== "string") return defaultValue;
+  const variables = { ...dateBuiltinVariables(), ...extraVariables ?? {} };
+  const trimmed = defaultValue.trim();
+  if (trimmed.startsWith("=")) {
+    try {
+      return evaluateExpression(trimmed.slice(1).trim(), { variables });
+    } catch {
+      return defaultValue;
+    }
+  }
+  if (defaultValue.includes("${")) {
+    try {
+      return interpolateVariables(defaultValue, variables);
+    } catch {
+      return defaultValue;
+    }
+  }
+  return defaultValue;
+}
+
+// ../dashboard-renderers/src/value-format.ts
+var compactFormatter = new Intl.NumberFormat("en-US", {
+  notation: "compact",
+  maximumFractionDigits: 1
+});
+var exactFormatter = new Intl.NumberFormat("en-US", {
+  maximumFractionDigits: 2
+});
+var NAMED_FORMATS = /* @__PURE__ */ new Set(["percent", "currency", "number"]);
+function formatCompactNumber(value) {
+  if (!Number.isFinite(value)) return "";
+  if (Math.abs(value) < 1e3) return exactFormatter.format(value);
+  return compactFormatter.format(value);
+}
+function formatValue(value, options = {}) {
+  if (value === void 0 || value === null) return "-";
+  const format2 = options.format ?? "number";
+  const notation = options.compact === true ? "compact" : "standard";
+  const places = typeof options.decimals === "number" && options.decimals >= 0 && options.decimals <= 20 ? Math.floor(options.decimals) : void 0;
+  const wrap = (text) => (options.prefix ?? "") + text + (options.suffix ?? "");
+  if (format2 === "currency") {
+    const currencyOptions = {
+      minimumFractionDigits: places ?? 2,
+      maximumFractionDigits: places ?? 2,
+      notation
+    };
+    if (options.compact === true) currencyOptions.compactDisplay = "short";
+    return wrap(new Intl.NumberFormat("en-US", currencyOptions).format(value));
+  }
+  if (format2 === "percent") {
+    return wrap(
+      new Intl.NumberFormat("en-US", {
+        style: "percent",
+        minimumFractionDigits: places,
+        maximumFractionDigits: places ?? 1
+      }).format(value)
+    );
+  }
+  const numberOptions = { notation };
+  if (options.compact === true) numberOptions.compactDisplay = "short";
+  if (places !== void 0) {
+    numberOptions.minimumFractionDigits = places;
+    numberOptions.maximumFractionDigits = places;
+  }
+  return wrap(new Intl.NumberFormat("en-US", numberOptions).format(value));
+}
+function namedFormatter(name) {
+  return (value) => formatValue(Number(value), { format: name, decimals: 1 });
+}
+function withNamedAxisFormatter(axis) {
+  if (!isRecord(axis)) return axis;
+  const label = isRecord(axis.axisLabel) ? { ...axis.axisLabel } : void 0;
+  if (label === void 0 || typeof label.formatter !== "string" || !NAMED_FORMATS.has(label.formatter)) {
+    return axis;
+  }
+  return {
+    ...axis,
+    axisLabel: { ...label, formatter: namedFormatter(label.formatter) }
+  };
+}
+function applyNamedFormatters(option) {
+  const next = { ...option };
+  for (const key of ["xAxis", "yAxis"]) {
+    const axes = option[key];
+    if (axes === void 0) continue;
+    next[key] = Array.isArray(axes) ? axes.map(withNamedAxisFormatter) : withNamedAxisFormatter(axes);
+  }
+  if (isRecord(option.tooltip)) {
+    const formatter = option.tooltip.valueFormatter;
+    if (typeof formatter === "string" && NAMED_FORMATS.has(formatter)) {
+      next.tooltip = {
+        ...option.tooltip,
+        valueFormatter: namedFormatter(formatter)
+      };
+    }
+  }
+  return next;
+}
+
+// ../dashboard-renderers/src/chart-defaults.ts
+var ZOOM_THRESHOLD = 60;
+var ROTATE_LABEL_COUNT = 6;
+var LONG_LABEL_CHARS = 10;
+var exactFormatter2 = new Intl.NumberFormat("en-US", {
+  maximumFractionDigits: 2
+});
+var MONTHS = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+var DATE_LABEL = /^(\d{4})-(\d{2})-(\d{2})/u;
+function niceCeil(value) {
+  if (value === 0) return 0;
+  const magnitude = 10 ** Math.floor(Math.log10(Math.abs(value)));
+  const step = magnitude / 2;
+  return Math.ceil(value / step) * step;
+}
+function niceFloor(value) {
+  if (value === 0) return 0;
+  const magnitude = 10 ** Math.floor(Math.log10(Math.abs(value)));
+  const step = magnitude / 2;
+  return Math.floor(value / step) * step;
+}
+function valueScaleBounds(values) {
+  let lowest = Number.POSITIVE_INFINITY;
+  let highest = Number.NEGATIVE_INFINITY;
+  for (const value of values) {
+    if (!Number.isFinite(value)) continue;
+    if (value < lowest) lowest = value;
+    if (value > highest) highest = value;
+  }
+  if (lowest > highest) return { min: 0, max: 1 };
+  const min = lowest < 0 ? niceFloor(lowest) : 0;
+  const max = niceCeil(highest);
+  return max <= min ? { min, max: min + 1 } : { min, max };
+}
+function formatDateLabel(value, withYear) {
+  const match = DATE_LABEL.exec(value);
+  if (match === null) return value;
+  const monthNumber = Number(match[2]);
+  const month = MONTHS[monthNumber - 1] ?? match[2] ?? "";
+  const day = String(Number(match[3]));
+  const year = match[1] ?? "";
+  return withYear ? `${month} ${day}, ${year.slice(2)}` : `${month} ${day}`;
+}
+function categoryData(axis) {
+  if (!Array.isArray(axis.data)) return [];
+  return axis.data.map(
+    (entry) => typeof entry === "string" || typeof entry === "number" ? String(entry) : isRecord(entry) ? String(entry.value ?? "") : ""
+  );
+}
+function looksLikeDates(values) {
+  if (values.length === 0) return false;
+  return values.filter((value) => DATE_LABEL.test(value)).length / values.length >= 0.8;
+}
+function withAxisLabelDefaults(axis) {
+  if (!isRecord(axis)) return axis;
+  const label = isRecord(axis.axisLabel) ? { ...axis.axisLabel } : {};
+  const hasFormatter = label.formatter !== void 0;
+  const type = typeof axis.type === "string" ? axis.type : "value";
+  if ((type === "value" || type === "log") && !hasFormatter) {
+    label.formatter = (value) => formatCompactNumber(value);
+  } else if (type === "category") {
+    const values = categoryData(axis);
+    if (!hasFormatter && looksLikeDates(values)) {
+      const years = new Set(values.map((value) => value.slice(0, 4)));
+      const withYear = years.size > 1;
+      label.formatter = (value) => formatDateLabel(value, withYear);
+    }
+    const longest = values.reduce(
+      (maximum, value) => Math.max(maximum, value.length),
+      0
+    );
+    if (label.rotate === void 0 && values.length > ROTATE_LABEL_COUNT && longest > LONG_LABEL_CHARS) {
+      label.rotate = 30;
+    }
+  }
+  if (label.hideOverlap === void 0) label.hideOverlap = true;
+  return { ...axis, axisLabel: label };
+}
+function mapAxis(axes) {
+  return Array.isArray(axes) ? axes.map(withAxisLabelDefaults) : withAxisLabelDefaults(axes);
+}
+function withTooltipDefaults(tooltip, seriesCount) {
+  const next = isRecord(tooltip) ? { ...tooltip } : {};
+  const trigger = typeof next.trigger === "string" ? next.trigger : "item";
+  if (next.valueFormatter === void 0) {
+    next.valueFormatter = (value) => typeof value === "number" && Number.isFinite(value) ? exactFormatter2.format(value) : Array.isArray(value) ? value.map((entry) => String(entry)).join(" to ") : String(value ?? "");
+  }
+  if (trigger === "axis") {
+    if (next.axisPointer === void 0) {
+      next.axisPointer = { type: seriesCount > 1 ? "cross" : "line" };
+    }
+    if (next.order === void 0 && seriesCount > 2) {
+      next.order = "valueDesc";
+    }
+  }
+  if (next.extraCssText === void 0) {
+    next.extraCssText = "max-height:280px;overflow:auto;box-shadow:0 4px 16px rgba(0,0,0,0.12);";
+  }
+  return next;
+}
+function longestSeriesLength(series) {
+  return series.reduce((maximum, entry) => {
+    if (!isRecord(entry) || !Array.isArray(entry.data)) return maximum;
+    return Math.max(maximum, entry.data.length);
+  }, 0);
+}
+function hasCategoryAxis(option) {
+  const axes = Array.isArray(option.xAxis) ? option.xAxis : [option.xAxis];
+  return axes.some((axis) => isRecord(axis) && axis.type === "category");
+}
+function applyChartDefaults(option) {
+  const next = { ...option };
+  const rawSeries = option.series;
+  const series = Array.isArray(rawSeries) ? rawSeries : rawSeries === void 0 || rawSeries === null ? [] : [rawSeries];
+  next.tooltip = withTooltipDefaults(option.tooltip, series.length);
+  if (option.xAxis !== void 0) next.xAxis = mapAxis(option.xAxis);
+  if (option.yAxis !== void 0) next.yAxis = mapAxis(option.yAxis);
+  if (isRecord(option.legend) && option.legend.type === void 0) {
+    next.legend = { ...option.legend, type: "scroll" };
+  }
+  const zoomable = longestSeriesLength(series) >= ZOOM_THRESHOLD && option.dataZoom === void 0 && hasCategoryAxis(option);
+  if (zoomable) {
+    next.dataZoom = [
+      {
+        type: "inside",
+        zoomOnMouseWheel: "shift",
+        moveOnMouseWheel: false,
+        moveOnMouseMove: false
+      },
+      { type: "slider", height: 14, bottom: 6, brushSelect: false }
+    ];
+    if (isRecord(next.legend) && (next.legend.bottom === 0 || next.legend.bottom === "0")) {
+      next.legend = { ...next.legend, bottom: 26 };
+    }
+    if (isRecord(option.grid) && option.grid.bottom === "10%") {
+      next.grid = { ...option.grid, bottom: 56 };
+    }
+  }
+  return next;
+}
+
+// ../dashboard-renderers/src/chart-options.ts
+var GAUGE_POINTER_ICONS = {
+  pointer: "path://M12.8,0.7l12,40.1H0.7L12.8,0.7z",
+  arrow: "path://M12,2 L22,22 H18 V40 H6 V22 H2 L12,2 z",
+  hand: "path://M12,0 C18,0 22,6 22,12 L22,30 C22,36 18,40 12,40 C6,40 2,36 2,30 L2,12 C2,6 6,0 12,0 z"
+};
+function rowsFrom(result) {
+  if (!Array.isArray(result.rows)) return [];
+  return result.rows.filter(isRecord);
+}
+function stringRecord(value) {
+  if (!isRecord(value)) return void 0;
+  const entries = Object.entries(value).filter(
+    (entry) => typeof entry[1] === "string"
+  );
+  return Object.fromEntries(entries);
+}
+function resolveGaugePointer(pointer) {
+  if (pointer === void 0 || pointer === null) return void 0;
+  const name = typeof pointer === "string" ? pointer : void 0;
+  const pointerObject = isRecord(pointer) ? pointer : void 0;
+  const iconName = name ?? (typeof pointerObject?.icon === "string" ? pointerObject.icon : void 0);
+  if (iconName === void 0 || GAUGE_POINTER_ICONS[iconName] === void 0) {
+    if (typeof pointerObject?.icon === "string" && pointerObject.icon.startsWith("path://")) {
+      return pointerObject;
+    }
+    return pointerObject;
+  }
+  const icon = GAUGE_POINTER_ICONS[iconName];
+  const resolved = {
+    length: "90%",
+    width: 20,
+    offsetCenter: ["0%", "-50%"],
+    itemStyle: { color: "inherit" },
+    ...pointerObject,
+    icon
+  };
+  if (isRecord(resolved.itemStyle) && resolved.itemStyle.color === "auto") {
+    resolved.itemStyle = { ...resolved.itemStyle, color: "inherit" };
+  }
+  return resolved;
+}
+function inferChartFields(rows) {
+  const first = rows[0];
+  if (first === void 0) {
+    return { x: "x", category: "category", value: "value" };
+  }
+  const keys = Object.keys(first);
+  const isNumeric = (key) => {
+    const cell = first[key];
+    return typeof cell === "number" || typeof cell === "string" && cell.trim() !== "" && !Number.isNaN(Number(cell));
+  };
+  const label = keys.find((key) => !isNumeric(key)) ?? keys[0] ?? "x";
+  const numeric = keys.find(isNumeric);
+  return {
+    x: keys.includes("x") ? "x" : label,
+    category: keys.includes("category") ? "category" : label,
+    value: keys.includes("value") ? "value" : numeric ?? keys[1] ?? keys[0] ?? "value"
+  };
+}
+function paddingFor(value) {
+  if (typeof value === "number" || typeof value === "string") {
+    return { top: value, right: value, bottom: value, left: value };
+  }
+  if (!isRecord(value)) return {};
+  const padding = {};
+  for (const key of ["top", "right", "bottom", "left"]) {
+    const entry = value[key];
+    if (typeof entry === "number" || typeof entry === "string") {
+      padding[key] = entry;
+    }
+  }
+  return padding;
+}
+function unique(rows, field) {
+  const values = rows.map(
+    (row) => row[field] === void 0 || row[field] === null ? "" : String(row[field])
+  );
+  return [...new Set(values)];
+}
+function groupBy(rows, field) {
+  return rows.reduce((groups, row) => {
+    const key = row[field] === void 0 ? "" : String(row[field]);
+    const group = groups[key] ?? [];
+    group.push(row);
+    groups[key] = group;
+    return groups;
+  }, {});
+}
+function sumBy(rows, groupField, valueField, groupValue) {
+  return rows.filter((row) => String(row[groupField]) === String(groupValue)).reduce((sum, row) => sum + Number(row[valueField] ?? 0), 0);
+}
+function maxBy(rows, field) {
+  return rows.reduce(
+    (maximum, row) => Math.max(maximum, Number(row[field] ?? 0)),
+    0
+  );
+}
+function resolveBaseline(baseline, rows, groupField, groupValue) {
+  if (typeof baseline === "number") return baseline;
+  if (typeof baseline !== "string") return void 0;
+  const parsed = Number(baseline);
+  return Number.isNaN(parsed) ? sumBy(rows, groupField, baseline, groupValue) : parsed;
+}
+function sortRowsBy(rows, field, order) {
+  return [...rows].sort((left, right) => {
+    const leftValue = left[field];
+    const rightValue = right[field];
+    if (leftValue === null || leftValue === void 0) {
+      if (rightValue === null || rightValue === void 0) return 0;
+      return order === "asc" ? 1 : -1;
+    }
+    if (rightValue === null || rightValue === void 0) {
+      return order === "asc" ? -1 : 1;
+    }
+    const leftNumber = Number(leftValue);
+    const rightNumber = Number(rightValue);
+    if (!Number.isNaN(leftNumber) && !Number.isNaN(rightNumber)) {
+      return order === "asc" ? leftNumber - rightNumber : rightNumber - leftNumber;
+    }
+    const comparison = String(leftValue).localeCompare(String(rightValue));
+    return order === "asc" ? comparison : -comparison;
+  });
+}
+function customSeriesOption(widget, rows, seriesConfigs, seriesTemplate, categoryField, valueField, chartType, baseOption, common) {
+  const categories = unique(rows, categoryField);
+  const series = seriesConfigs.map((configuration) => {
+    const field = stringValue(configuration.field);
+    const seriesRest = { ...configuration };
+    delete seriesRest.field;
+    delete seriesRest.baseline;
+    const currentValueField = field ?? valueField;
+    const data = categories.map((category) => {
+      const value = sumBy(rows, categoryField, currentValueField, category);
+      const baseline = resolveBaseline(
+        configuration.baseline,
+        rows,
+        categoryField,
+        category
+      );
+      return baseline === void 0 ? value : [baseline, value];
+    });
+    return {
+      ...seriesTemplate,
+      ...seriesRest,
+      name: stringValue(configuration.name) ?? field ?? widget.metadata.name,
+      data,
+      type: stringValue(configuration.type) ?? chartType
+    };
+  });
+  return {
+    ...common,
+    xAxis: {
+      ...record(baseOption.xAxis),
+      type: "category",
+      data: categories,
+      axisLabel: { interval: "auto", hideOverlap: true }
+    },
+    yAxis: baseOption.yAxis === void 0 ? { type: "value" } : record(baseOption.yAxis),
+    legend: baseOption.legend === void 0 ? { bottom: 0 } : record(baseOption.legend),
+    series
+  };
+}
+function buildChartOption(widget, result) {
+  const mappings = record(widget.spec.mappings);
+  const display = displayBlock(widget, "echarts");
+  const xSort = record(display.xSort);
+  const xSortField = stringValue(xSort.by) ?? stringValue(mappings.x_order);
+  const xSortOrder = xSort.order === "desc" ? "desc" : "asc";
+  let rows = rowsFrom(result);
+  const resultVariables = record(result.variables);
+  const variables = evaluateVariables(
+    stringRecord(display.variables),
+    rows,
+    resultVariables
+  );
+  rows = applyFilter(stringValue(display.filter), rows, variables);
+  if (xSortField !== void 0) {
+    rows = sortRowsBy(rows, xSortField, xSortOrder);
+  }
+  const displayForInterpolation = { ...display };
+  delete displayForInterpolation.variables;
+  delete displayForInterpolation.filter;
+  const interpolated = record(
+    interpolateVariables(displayForInterpolation, variables)
+  );
+  const baseOption = record(interpolated.option);
+  const rawSeries = baseOption.series;
+  const seriesArray = Array.isArray(rawSeries) ? rawSeries : [rawSeries];
+  const seriesTemplate = record(seriesArray[0]);
+  const chartType = stringValue(seriesTemplate.type) ?? "line";
+  const inferred = inferChartFields(rows);
+  const xField = stringValue(mappings.x) ?? inferred.x;
+  const yField = stringValue(mappings.y) ?? inferred.value;
+  const categoryField = stringValue(mappings.category) ?? inferred.category;
+  const valueField = stringValue(mappings.value) ?? inferred.value;
+  const seriesField = stringValue(mappings.series);
+  const chartPadding = paddingFor(interpolated.chartPadding);
+  const baseOptionRest = { ...baseOption };
+  delete baseOptionRest.grid;
+  const grid = {
+    left: chartPadding.left ?? (chartType === "gauge" ? "0%" : "5%"),
+    right: chartPadding.right ?? (chartType === "gauge" ? "0%" : "5%"),
+    top: chartPadding.top ?? (chartType === "gauge" ? "0%" : "5%"),
+    bottom: chartPadding.bottom ?? (chartType === "gauge" ? "0%" : "10%"),
+    containLabel: true,
+    ...record(baseOption.grid)
+  };
+  const common = {
+    tooltip: {
+      trigger: chartType === "pie" || chartType === "gauge" ? "item" : "axis",
+      appendToBody: true,
+      confine: false
+    },
+    grid,
+    ...baseOptionRest
+  };
+  const customSeries = Array.isArray(interpolated.series) ? interpolated.series.filter(isRecord) : [];
+  if (customSeries.length > 0) {
+    return customSeriesOption(
+      widget,
+      rows,
+      customSeries,
+      seriesTemplate,
+      categoryField,
+      valueField,
+      chartType,
+      baseOptionRest,
+      common
+    );
+  }
+  if (chartType === "gauge") {
+    const first = rows[0] ?? {};
+    const startAngle = Number(seriesTemplate.startAngle);
+    const endAngle = Number(seriesTemplate.endAngle);
+    const semicircle = Number.isFinite(startAngle) && Number.isFinite(endAngle) && Math.abs(endAngle - startAngle) <= 180;
+    return {
+      ...common,
+      series: [
+        {
+          ...seriesTemplate,
+          radius: seriesTemplate.radius ?? (semicircle ? "90%" : "95%"),
+          center: seriesTemplate.center ?? (semicircle ? ["50%", "85%"] : ["50%", "55%"]),
+          ...semicircle ? {
+            title: {
+              offsetCenter: ["0%", "20%"],
+              ...record(seriesTemplate.title)
+            },
+            detail: {
+              offsetCenter: ["0%", "-5%"],
+              ...record(seriesTemplate.detail)
+            }
+          } : {},
+          pointer: resolveGaugePointer(seriesTemplate.pointer),
+          data: [
+            {
+              value: Number(first[valueField] ?? 0),
+              name: widget.metadata.name
+            }
+          ]
+        }
+      ]
+    };
+  }
+  if (chartType === "pie") {
+    const data2 = unique(rows, categoryField).map((category) => ({
+      name: category,
+      value: sumBy(rows, categoryField, valueField, category)
+    }));
+    return {
+      ...common,
+      series: [
+        {
+          ...seriesTemplate,
+          data: data2,
+          radius: seriesTemplate.radius ?? ["0%", "80%"]
+        }
+      ]
+    };
+  }
+  if (chartType === "heatmap") {
+    const yCategoryField = stringValue(mappings.y) ?? "y";
+    const data2 = rows.map((row) => [
+      row[xField],
+      row[yCategoryField],
+      Number(row[valueField] ?? 0)
+    ]);
+    return {
+      ...common,
+      xAxis: {
+        ...record(baseOptionRest.xAxis),
+        type: "category",
+        data: unique(rows, xField),
+        axisLabel: { interval: "auto", hideOverlap: true }
+      },
+      yAxis: {
+        ...record(baseOptionRest.yAxis),
+        type: "category",
+        data: unique(rows, yCategoryField),
+        axisLabel: { interval: "auto", hideOverlap: true }
+      },
+      visualMap: {
+        ...valueScaleBounds(data2.map((cell) => Number(cell[2]))),
+        calculable: true,
+        orient: "horizontal",
+        left: "center",
+        bottom: 0,
+        ...record(baseOptionRest.visualMap)
+      },
+      series: [
+        {
+          ...seriesTemplate,
+          data: data2,
+          encode: { x: xField, y: yCategoryField, value: valueField }
+        }
+      ]
+    };
+  }
+  if (chartType === "scatter") {
+    const groups = seriesField === void 0 ? { [widget.metadata.name]: rows } : groupBy(rows, seriesField);
+    return {
+      ...common,
+      xAxis: { ...record(baseOptionRest.xAxis), type: "value" },
+      yAxis: { ...record(baseOptionRest.yAxis), type: "value" },
+      legend: { bottom: 0 },
+      series: Object.entries(groups).map(([name, group]) => ({
+        ...seriesTemplate,
+        name,
+        data: group.map((row) => [
+          Number(row[xField] ?? 0),
+          Number(row[yField] ?? 0)
+        ]),
+        type: "scatter"
+      }))
+    };
+  }
+  if (chartType === "radar") {
+    const categories2 = unique(rows, categoryField);
+    return {
+      ...common,
+      radar: {
+        indicator: categories2.map((category) => ({
+          name: category,
+          max: maxBy(rows, valueField)
+        }))
+      },
+      series: [
+        {
+          ...seriesTemplate,
+          data: [
+            {
+              value: categories2.map(
+                (category) => sumBy(rows, categoryField, valueField, category)
+              ),
+              name: widget.metadata.name
+            }
+          ]
+        }
+      ]
+    };
+  }
+  if (seriesField !== void 0) {
+    const xValues = unique(rows, xField);
+    const groups = groupBy(rows, seriesField);
+    const seriesWithoutBaseline = { ...seriesTemplate };
+    const baseline = seriesWithoutBaseline.baseline;
+    delete seriesWithoutBaseline.baseline;
+    return {
+      ...common,
+      xAxis: {
+        ...record(baseOptionRest.xAxis),
+        type: "category",
+        data: xValues,
+        axisLabel: { interval: "auto", hideOverlap: true }
+      },
+      yAxis: baseOptionRest.yAxis === void 0 ? { type: "value" } : record(baseOptionRest.yAxis),
+      legend: baseOptionRest.legend === void 0 ? { bottom: 0 } : record(baseOptionRest.legend),
+      series: Object.entries(groups).map(([name, group]) => ({
+        ...seriesWithoutBaseline,
+        name,
+        data: xValues.map((x) => {
+          const row = group.find(
+            (candidate) => String(candidate[xField]) === String(x)
+          );
+          const value = Number(row?.[yField] ?? 0);
+          const base = resolveBaseline(baseline, group, xField, x);
+          return base === void 0 ? value : [base, value];
+        }),
+        type: chartType
+      }))
+    };
+  }
+  const categories = unique(rows, categoryField);
+  const data = categories.map((category) => {
+    const value = sumBy(rows, categoryField, valueField, category);
+    const baseline = resolveBaseline(
+      seriesTemplate.baseline,
+      rows,
+      categoryField,
+      category
+    );
+    return baseline === void 0 ? value : [baseline, value];
+  });
+  if (chartType === "bar" && interpolated.orientation === "horizontal") {
+    return {
+      ...common,
+      xAxis: { ...record(baseOptionRest.xAxis), type: "value" },
+      yAxis: {
+        ...record(baseOptionRest.yAxis),
+        type: "category",
+        data: categories,
+        axisLabel: { interval: "auto", hideOverlap: true }
+      },
+      series: [{ ...seriesTemplate, data, type: "bar" }]
+    };
+  }
+  return {
+    ...common,
+    xAxis: {
+      ...record(baseOptionRest.xAxis),
+      type: "category",
+      data: categories,
+      axisLabel: { interval: "auto", hideOverlap: true }
+    },
+    yAxis: baseOptionRest.yAxis === void 0 ? { type: "value" } : record(baseOptionRest.yAxis),
+    series: [{ ...seriesTemplate, data }]
+  };
+}
+function chartAxisKey(option) {
+  if (!isRecord(option)) return "";
+  const axes = Array.isArray(option.xAxis) ? option.xAxis : [option.xAxis];
+  const axis = axes.find(
+    (entry) => isRecord(entry) && entry.type === "category"
+  );
+  if (!isRecord(axis) || !Array.isArray(axis.data)) return "";
+  const values = axis.data.map(
+    (entry) => isRecord(entry) ? String(entry.value ?? "") : String(entry)
+  );
+  if (values.length === 0) return "";
+  return `${values.length}|${values[0]}|${values[values.length - 1]}`;
+}
+
+// ../dashboard-renderers/src/chart-theme.ts
+function buildChartTheme(tokens) {
+  const axis = {
+    axisLine: { show: true, lineStyle: { color: tokens.border } },
+    axisTick: { show: false },
+    axisLabel: { color: tokens.mutedForeground, fontSize: 11 },
+    splitLine: {
+      show: true,
+      lineStyle: { color: tokens.border, type: "dashed", opacity: 0.7 }
+    },
+    splitArea: { show: false }
+  };
+  return {
+    color: [...tokens.seriesColors],
+    backgroundColor: "transparent",
+    textStyle: { fontFamily: tokens.fontFamily, color: tokens.foreground },
+    title: {
+      textStyle: { color: tokens.foreground, fontWeight: 600 },
+      subtextStyle: { color: tokens.mutedForeground }
+    },
+    legend: {
+      textStyle: { color: tokens.mutedForeground },
+      itemWidth: 10,
+      itemHeight: 10,
+      icon: "roundRect"
+    },
+    tooltip: {
+      backgroundColor: tokens.surface,
+      borderColor: tokens.border,
+      borderWidth: 1,
+      textStyle: { color: tokens.surfaceForeground, fontSize: 12 },
+      axisPointer: {
+        lineStyle: { color: tokens.border },
+        crossStyle: { color: tokens.border },
+        label: { backgroundColor: tokens.mutedForeground }
+      }
+    },
+    categoryAxis: { ...axis, splitLine: { show: false } },
+    valueAxis: axis,
+    logAxis: axis,
+    timeAxis: axis,
+    line: { symbol: "circle", symbolSize: 6, lineStyle: { width: 2 } },
+    bar: { itemStyle: { borderRadius: [3, 3, 0, 0] } },
+    pie: { itemStyle: { borderColor: tokens.surface, borderWidth: 1 } },
+    visualMap: {
+      textStyle: { color: tokens.mutedForeground },
+      inRange: {
+        color: [...tokens.heatmapColors ?? tokens.seriesColors.slice(0, 3)]
+      }
+    },
+    dataZoom: {
+      borderColor: tokens.border,
+      textStyle: { color: tokens.mutedForeground }
+    },
+    toolbox: { iconStyle: { borderColor: tokens.mutedForeground } }
+  };
+}
+var CHART_MOTION = {
+  animation: true,
+  animationDuration: 520,
+  animationEasing: "cubicOut",
+  animationDelay: (index) => Math.min(index, 40) * 12,
+  animationDurationUpdate: 420,
+  animationEasingUpdate: "cubicInOut",
+  animationDelayUpdate: (index) => Math.min(index, 40) * 6
+};
+var CHART_MOTION_OFF = {
+  animation: false,
+  animationDuration: 0,
+  animationDurationUpdate: 0,
+  animationDelay: 0,
+  animationDelayUpdate: 0
+};
+function withChartMotion(option, reduced) {
+  const next = {
+    ...reduced ? CHART_MOTION_OFF : CHART_MOTION
+  };
+  for (const [key, value] of Object.entries(option)) {
+    if (value !== void 0) next[key] = value;
+  }
+  return next;
+}
+function chartStructureKey(option) {
+  const rawSeries = option.series;
+  const series = Array.isArray(rawSeries) ? rawSeries : rawSeries === void 0 || rawSeries === null ? [] : [rawSeries];
+  const seriesKey = series.map(
+    (entry) => isRecord(entry) ? `${String(entry.type ?? "")}|${String(entry.name ?? "")}` : "?"
+  ).join(",");
+  const axisKey = ["xAxis", "yAxis"].map((key) => {
+    const axes = Array.isArray(option[key]) ? option[key] : [option[key]];
+    return axes.map((axis) => isRecord(axis) ? String(axis.type ?? "") : "").join("/");
+  }).join(";");
+  const extras = ["radar", "visualMap", "dataZoom"].map((key) => option[key] === void 0 ? "0" : "1").join("");
+  return `${seriesKey}#${axisKey}#${extras}`;
+}
+function chartLoadingOptions(tokens, mode) {
+  return {
+    text: "Refreshing",
+    color: tokens.seriesColors[0] ?? tokens.foreground,
+    textColor: tokens.mutedForeground,
+    maskColor: mode === "dark" ? "rgba(15, 17, 21, 0.55)" : "rgba(250, 251, 252, 0.6)",
+    zlevel: 0,
+    fontFamily: tokens.fontFamily,
+    fontSize: 12
+  };
+}
+
+// ../dashboard-renderers/src/chart-model.ts
+function buildChartRendererModel(widget, result, context = {}) {
+  const option = withChartMotion(
+    applyChartDefaults(applyNamedFormatters(buildChartOption(widget, result))),
+    context.reducedMotion === true
+  );
+  return {
+    kind: "chart",
+    frame: rendererFrame(
+      widget,
+      "echarts",
+      context.widgetDefaults,
+      context.framed
+    ),
+    option,
+    axisKey: chartAxisKey(option),
+    structureKey: chartStructureKey(option),
+    loading: context.loading === true
+  };
+}
+
+export { applyChartDefaults, applyFilter, applyNamedFormatters, buildChartOption, buildChartRendererModel, buildChartTheme, chartAxisKey, chartLoadingOptions, chartStructureKey, evaluateExpression, evaluateVariables, formatCompactNumber, formatValue, inferChartFields, interpolateVariables, resolveFilterDefault, valueScaleBounds, withChartMotion };
+//# sourceMappingURL=chunk-OMPR32AR.js.map
+//# sourceMappingURL=chunk-OMPR32AR.js.map