@dlh.io/bideux 0.1.0

package/dist/chunk-LHD445PJ.js

@@ -0,0 +1,571 @@
+import { tableExportModel } from './chunk-QDQ5VVTC.js';
+import { rendererFrame, getClickInteraction } from './chunk-75CRTQK7.js';
+
+// ../dashboard-renderers/src/types.ts
+var PIVOT_META_PROP = "__pivotMeta";
+
+// ../dashboard-renderers/src/pivot-columns.ts
+function isPivotColumnGroup(definition) {
+  return "children" in definition;
+}
+function readPivotPayload(result) {
+  const pivot = result?.pivot;
+  if (typeof pivot !== "object" || pivot === null || Array.isArray(pivot)) {
+    return null;
+  }
+  const candidate = pivot;
+  if (!Array.isArray(candidate.rows) || !Array.isArray(candidate.measures)) {
+    return null;
+  }
+  if (!Array.isArray(candidate.column_tree) || !Array.isArray(candidate.row_fields)) {
+    return null;
+  }
+  return pivot;
+}
+function buildPivotColumns(payload, collapsedColumns = /* @__PURE__ */ new Set()) {
+  const rowColumns = payload.row_fields.map(
+    (field) => ({
+      prop: field.key,
+      name: field.label,
+      columnKey: null,
+      measure: null,
+      isTotal: false,
+      isRowField: true,
+      pinStart: true
+    })
+  );
+  return [
+    ...rowColumns,
+    ...payload.column_tree.map(
+      (node) => toColumnDefinition(node, collapsedColumns)
+    )
+  ];
+}
+function toColumnDefinition(node, collapsedColumns) {
+  if (node.children.length > 0) {
+    const children = visibleChildren(node, collapsedColumns);
+    return {
+      name: node.label,
+      key: node.key,
+      foldable: node.children.some((child) => child.is_group_total),
+      folded: collapsedColumns.has(node.key),
+      leafCount: countValueLeaves(node),
+      children: children.map(
+        (child) => toColumnDefinition(child, collapsedColumns)
+      )
+    };
+  }
+  return {
+    prop: node.column ?? node.key,
+    name: node.label,
+    columnKey: node.column,
+    measure: node.measure,
+    isTotal: node.is_total,
+    isRowField: false,
+    pinStart: false
+  };
+}
+function countValueLeaves(node) {
+  if (node.children.length === 0) {
+    return node.is_group_total || node.is_total ? 0 : 1;
+  }
+  return node.children.reduce((sum, child) => sum + countValueLeaves(child), 0);
+}
+function visibleChildren(node, collapsedColumns) {
+  if (!collapsedColumns.has(node.key)) return node.children;
+  const totals = node.children.filter((child) => child.is_group_total);
+  return totals.length > 0 ? totals : node.children;
+}
+function pivotColumnGroups(payload) {
+  const groups = [];
+  const walk = (nodes, prefix) => {
+    for (const node of nodes) {
+      if (node.children.length === 0) continue;
+      const path = [...prefix, node.label];
+      if (node.children.some((child) => child.is_group_total)) {
+        groups.push({ key: node.key, label: path.join(" / ") });
+      }
+      walk(node.children, path);
+    }
+  };
+  walk(payload.column_tree, []);
+  return groups;
+}
+function pivotValueColumns(payload, collapsedColumns = /* @__PURE__ */ new Set()) {
+  const columns = [];
+  const walk = (nodes, prefix) => {
+    for (const node of nodes) {
+      const path = [...prefix, node.label];
+      if (node.children.length === 0) {
+        if (node.column !== null) {
+          columns.push({ key: node.column, label: path.join(" / ") });
+        }
+        continue;
+      }
+      walk(visibleChildren(node, collapsedColumns), path);
+    }
+  };
+  walk(payload.column_tree, []);
+  return columns;
+}
+function buildPivotRows(payload, rows = payload.rows) {
+  const fields = payload.row_fields.map((field) => field.key);
+  const spellOutPath = payload.subtotals === "none";
+  return rows.map(
+    (row) => toGridRow(row, fields, spellOutPath, payload.column_keys)
+  );
+}
+function buildPivotTotalRow(payload) {
+  if (payload.total_row === null) return null;
+  const fields = payload.row_fields.map((field) => field.key);
+  return toGridRow(payload.total_row, fields, false, payload.column_keys);
+}
+function pivotRowFilters(payload, meta) {
+  const filters = {};
+  payload.row_fields.forEach((field, index) => {
+    const value = meta.path[index];
+    if (value !== void 0) filters[field.key] = value;
+  });
+  return filters;
+}
+function pivotColumnFilters(payload, prop) {
+  const walk = (nodes, path) => {
+    for (const node of nodes) {
+      if (node.children.length === 0) {
+        if (node.column !== prop) continue;
+        if (node.is_total) return {};
+        const filters = {};
+        payload.column_fields.forEach((field, index) => {
+          const value = path[index];
+          if (value !== void 0) filters[field.key] = value;
+        });
+        return filters;
+      }
+      const found = walk(
+        node.children,
+        node.is_total ? path : [...path, node.label]
+      );
+      if (found !== null) return found;
+    }
+    return null;
+  };
+  return walk(payload.column_tree, []);
+}
+function toGridRow(row, fields, spellOutPath, columnKeys) {
+  const meta = {
+    key: row.key,
+    label: row.label,
+    path: row.path,
+    depth: row.depth,
+    kind: row.kind
+  };
+  const grid = { [PIVOT_META_PROP]: meta };
+  fields.forEach((field, index) => {
+    if (row.kind === "grand_total" || row.kind === "other") {
+      grid[field] = index === 0 ? row.label : "";
+      return;
+    }
+    if (spellOutPath) {
+      grid[field] = row.path[index] ?? "";
+      return;
+    }
+    grid[field] = index === row.depth ? row.label : "";
+  });
+  for (const key of columnKeys) {
+    const value = row.cells[key];
+    grid[key] = value === void 0 ? null : value;
+  }
+  return grid;
+}
+function pivotMeasuresByKey(payload) {
+  return new Map(payload.measures.map((measure) => [measure.key, measure]));
+}
+function pivotRowMeta(row) {
+  const meta = row?.[PIVOT_META_PROP];
+  if (typeof meta !== "object" || meta === null || Array.isArray(meta)) {
+    return null;
+  }
+  const candidate = meta;
+  if (typeof candidate.depth !== "number" || typeof candidate.kind !== "string") {
+    return null;
+  }
+  return meta;
+}
+function formatPivotValue(value, measure, emptyValue) {
+  if (value === null || value === void 0 || value === "") return emptyValue;
+  const number = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(number)) return emptyValue;
+  const format = measure?.format ?? "number";
+  const decimals = measure?.decimals ?? void 0;
+  if (format === "currency") {
+    return new Intl.NumberFormat("en-US", {
+      style: "currency",
+      currency: "USD",
+      minimumFractionDigits: decimals ?? 0,
+      maximumFractionDigits: decimals ?? 0
+    }).format(number);
+  }
+  if (format === "percent") {
+    return new Intl.NumberFormat("en-US", {
+      style: "percent",
+      minimumFractionDigits: decimals ?? 1,
+      maximumFractionDigits: decimals ?? 1
+    }).format(number);
+  }
+  return new Intl.NumberFormat("en-US", {
+    minimumFractionDigits: decimals ?? 0,
+    maximumFractionDigits: decimals ?? (Number.isInteger(number) ? 0 : 2)
+  }).format(number);
+}
+function pivotHeatmapIntensity(value, range) {
+  if (range === void 0) return null;
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  const span = range.max - range.min;
+  if (span <= 0) return null;
+  const ratio = (value - range.min) / span;
+  return Math.min(1, Math.max(0, ratio));
+}
+function pivotTruncationNote(payload) {
+  const notes = [];
+  if (payload.truncated.row_groups > 0) {
+    const shown = payload.truncated.row_groups_total - payload.truncated.row_groups;
+    const rolled = payload.truncated.rolled_up > 0 ? `, with ${payload.truncated.rolled_up} in Other` : "";
+    notes.push(
+      `${shown} of ${payload.truncated.row_groups_total} row groups${rolled}`
+    );
+  }
+  if (payload.truncated.columns > 0) {
+    const shown = payload.truncated.columns_total - payload.truncated.columns;
+    notes.push(`${shown} of ${payload.truncated.columns_total} columns`);
+  }
+  return notes.length > 0 ? `Showing ${notes.join(" and ")}.` : null;
+}
+
+// ../dashboard-renderers/src/pivot-view.ts
+function initialPivotViewState(payload, capture = false) {
+  return {
+    collapsed: initialCollapsed(payload, capture),
+    collapsedColumns: initialCollapsedColumns(payload, capture),
+    search: "",
+    filters: {},
+    sort: null
+  };
+}
+function initialCollapsed(payload, capture) {
+  if (capture && typeof payload.snapshot_expand === "number") {
+    return new Set(
+      payload.rows.filter(
+        (row) => row.kind === "group" && row.depth >= payload.snapshot_expand
+      ).map((row) => row.key)
+    );
+  }
+  return payload.subtotals === "collapsed" ? new Set(pivotGroupKeys(payload)) : /* @__PURE__ */ new Set();
+}
+function initialCollapsedColumns(payload, capture) {
+  if (!capture || typeof payload.snapshot_expand_columns !== "number") {
+    return /* @__PURE__ */ new Set();
+  }
+  const open = payload.snapshot_expand_columns;
+  const folded = /* @__PURE__ */ new Set();
+  const walk = (nodes, level) => {
+    for (const node of nodes) {
+      if (node.children.length === 0 || node.is_total) continue;
+      if (level >= open && node.children.some((child) => child.is_group_total)) {
+        folded.add(node.key);
+        continue;
+      }
+      walk(node.children, level + 1);
+    }
+  };
+  walk(payload.column_tree, 0);
+  return folded;
+}
+function pivotOpenRowLevels(payload, state) {
+  if (state.collapsed.size === 0) return null;
+  let shallowest = null;
+  for (const row of payload.rows) {
+    if (row.kind !== "group" || !state.collapsed.has(row.key)) continue;
+    if (shallowest === null || row.depth < shallowest) {
+      shallowest = row.depth;
+    }
+  }
+  return shallowest;
+}
+function pivotOpenColumnLevels(payload, state) {
+  if (state.collapsedColumns.size === 0) return null;
+  let shallowest = null;
+  const walk = (nodes, level) => {
+    for (const node of nodes) {
+      if (node.children.length === 0 || node.is_total) continue;
+      if (state.collapsedColumns.has(node.key)) {
+        if (shallowest === null || level < shallowest) shallowest = level;
+        continue;
+      }
+      walk(node.children, level + 1);
+    }
+  };
+  walk(payload.column_tree, 0);
+  return shallowest;
+}
+function pivotSignature(payload) {
+  return [
+    payload.row_fields.map((field) => field.key).join(","),
+    payload.column_fields.map((field) => field.key).join(","),
+    payload.measures.map((measure) => measure.key).join(","),
+    payload.subtotals
+  ].join("|");
+}
+function pivotGroupKeys(payload) {
+  return payload.rows.filter((row) => row.kind === "group").map((row) => row.key);
+}
+function pivotHasGroups(payload) {
+  return payload.rows.some((row) => row.kind === "group");
+}
+function pivotFilterCount(state) {
+  return Object.keys(state.filters).length;
+}
+function setPivotColumnFilter(filters, column, filter) {
+  const next = { ...filters };
+  if (filter === null) {
+    delete next[column];
+  } else {
+    next[column] = filter;
+  }
+  return next;
+}
+function pivotFilterKeeps(value, filter) {
+  switch (filter.op) {
+    case "gte":
+      return value >= filter.value;
+    case "gt":
+      return value > filter.value;
+    case "eq":
+      return value === filter.value;
+    case "lte":
+      return value <= filter.value;
+    case "lt":
+      return value < filter.value;
+  }
+}
+function pivotVisibleRows(payload, state) {
+  const tree = pivotTree(payload.rows);
+  const sorted = state.sort === null ? tree : sortNodes(tree, state.sort, payload);
+  const kept = filterNodes(sorted, state);
+  const visible = [];
+  collect(kept, state.collapsed, visible);
+  return visible;
+}
+function pivotSortDirection(state, payload, column) {
+  if (state.sort !== null) {
+    return state.sort.column === column ? state.sort.direction : null;
+  }
+  return payload.sort.column === column ? payload.sort.direction : null;
+}
+function nextPivotSort(state, payload, column) {
+  const first = payload.column_keys.includes(column) ? "desc" : "asc";
+  if (state.sort?.column !== column) return { column, direction: first };
+  if (state.sort.direction === first) {
+    return { column, direction: first === "asc" ? "desc" : "asc" };
+  }
+  return null;
+}
+function togglePivotGroup(collapsed, key) {
+  const next = new Set(collapsed);
+  if (!next.delete(key)) next.add(key);
+  return next;
+}
+function pivotTree(rows) {
+  const roots = [];
+  const openByDepth = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const node = { row, children: [] };
+    const parent = row.depth > 0 ? openByDepth.get(row.depth - 1) : void 0;
+    if (parent === void 0) {
+      roots.push(node);
+    } else {
+      parent.children.push(node);
+    }
+    if (row.kind === "group") openByDepth.set(row.depth, node);
+  }
+  return roots;
+}
+function sortNodes(nodes, sort, payload) {
+  const isValue = payload.column_keys.includes(sort.column);
+  const rank = payload.row_fields.findIndex(
+    (field) => field.key === sort.column
+  );
+  const ordered = [...nodes].sort(
+    (left, right) => isValue ? compareValues(
+      left.row.cells[sort.column],
+      right.row.cells[sort.column],
+      sort.direction
+    ) : compareLabels(left.row, right.row, rank, sort.direction)
+  );
+  return ordered.map((node) => ({
+    row: node.row,
+    children: sortNodes(node.children, sort, payload)
+  }));
+}
+function compareValues(left, right, direction) {
+  const missing = (value) => value === null || value === void 0 || !Number.isFinite(value);
+  if (missing(left) && missing(right)) return 0;
+  if (missing(left)) return 1;
+  if (missing(right)) return -1;
+  const difference = left - right;
+  return direction === "desc" ? -difference : difference;
+}
+function compareLabels(left, right, rank, direction) {
+  const at = rank >= 0 ? rank : Math.max(left.depth, 0);
+  const a = left.path[at] ?? left.label;
+  const b = right.path[at] ?? right.label;
+  const order = a.localeCompare(b, void 0, {
+    numeric: true,
+    sensitivity: "base"
+  });
+  return direction === "desc" ? -order : order;
+}
+function filterNodes(nodes, state) {
+  const query = state.search.trim().toLowerCase();
+  const filters = Object.entries(state.filters);
+  if (query === "" && filters.length === 0) return nodes;
+  const keep = (node) => {
+    const children = node.children.map(keep).filter((child) => child !== null);
+    if (children.length > 0) return { row: node.row, children };
+    if (node.row.kind === "group") return null;
+    if (query !== "" && !matchesQuery(node.row, query)) return null;
+    for (const [column, filter] of filters) {
+      const value = node.row.cells[column];
+      if (typeof value !== "number" || !pivotFilterKeeps(value, filter)) {
+        return null;
+      }
+    }
+    return { row: node.row, children: [] };
+  };
+  return nodes.map(keep).filter((node) => node !== null);
+}
+function matchesQuery(row, query) {
+  return row.path.some((label) => label.toLowerCase().includes(query));
+}
+function collect(nodes, collapsed, into) {
+  for (const node of nodes) {
+    into.push(node.row);
+    if (collapsed.has(node.row.key)) continue;
+    collect(node.children, collapsed, into);
+  }
+}
+
+// ../dashboard-renderers/src/pivot-model.ts
+function buildPivotRendererModel(widget, result, context = {}) {
+  const frame = rendererFrame(
+    widget,
+    "pivot_table",
+    context.widgetDefaults,
+    context.framed
+  );
+  const payload = readPivotPayload(result);
+  if (payload === null) {
+    const missing = {
+      kind: "pivot",
+      status: "missing",
+      frame,
+      message: "This widget did not return a pivot table."
+    };
+    return missing;
+  }
+  const view = context.pivotView ?? initialPivotViewState(payload, context.capture);
+  const visibleRows = pivotVisibleRows(payload, view);
+  const ready = {
+    kind: "pivot",
+    status: "ready",
+    frame,
+    payload,
+    view,
+    columns: buildPivotColumns(payload, view.collapsedColumns),
+    rows: buildPivotRows(payload, visibleRows),
+    totalRow: buildPivotTotalRow(payload),
+    valueColumns: pivotValueColumns(payload, view.collapsedColumns),
+    columnGroups: pivotColumnGroups(payload),
+    truncation: pivotTruncationNote(payload),
+    controls: {
+      searchPlaceholder: "Search rows",
+      expandable: pivotHasGroups(payload),
+      groupCount: pivotGroupKeys(payload).length,
+      filterCount: pivotFilterCount(view),
+      reordered: view.sort !== null,
+      canFilter: true,
+      canRearrange: false,
+      embedded: context.embedded === true
+    },
+    exports: tableExportModel(
+      typeof widget.spec.display === "object" && widget.spec.display !== null && !Array.isArray(widget.spec.display) && typeof widget.spec.display.pivot_table === "object" && widget.spec.display.pivot_table !== null && !Array.isArray(widget.spec.display.pivot_table) ? widget.spec.display.pivot_table : {},
+      widget.metadata.name,
+      context.excelExport !== false
+    ),
+    openLevels: {
+      rows: pivotOpenRowLevels(payload, view),
+      columns: pivotOpenColumnLevels(payload, view)
+    }
+  };
+  return ready;
+}
+function pivotCellPresentation(model, row, column) {
+  if (column.isRowField) {
+    return {
+      text: String(row[column.prop] ?? ""),
+      align: "left",
+      emphasized: false,
+      heatmapIntensity: null
+    };
+  }
+  const meta = row.__pivotMeta;
+  const value = row[column.prop];
+  const measure = pivotMeasuresByKey(model.payload).get(column.measure ?? "");
+  const shade = model.payload.heatmap_measure !== null && column.measure === model.payload.heatmap_measure && column.columnKey !== null && !column.isTotal && meta?.kind !== "group" && meta?.kind !== "grand_total" ? pivotHeatmapIntensity(
+    value,
+    model.payload.value_range[column.measure ?? ""]
+  ) : null;
+  return {
+    text: formatPivotValue(value, measure, model.payload.empty_value),
+    align: "right",
+    emphasized: column.isTotal || meta?.kind === "group" || meta?.kind === "grand_total",
+    heatmapIntensity: shade
+  };
+}
+function pivotCellAction(model, widget, row, column, value, detailAvailable = true) {
+  if (column.isRowField && row.kind === "group") {
+    return { kind: "toggle-row-group", key: row.key };
+  }
+  const columnFilters = column.columnKey === null ? null : pivotColumnFilters(model.payload, column.columnKey);
+  const interaction = getClickInteraction(widget);
+  if (interaction !== void 0) {
+    return {
+      kind: "interaction",
+      interaction,
+      context: {
+        widgetId: widget.metadata.id,
+        data: {
+          ...pivotRowFilters(model.payload, row),
+          ...columnFilters ?? {},
+          column: column.columnKey
+        },
+        value
+      }
+    };
+  }
+  if (!detailAvailable || columnFilters === null || row.kind === "other" || row.kind === "grand_total") {
+    return null;
+  }
+  const rowFilters = pivotRowFilters(model.payload, row);
+  const labelParts = [...row.path];
+  const columnLabel = column.columnKey === null ? void 0 : model.payload.column_labels[column.columnKey];
+  if (columnLabel !== void 0) labelParts.push(columnLabel);
+  return {
+    kind: "detail",
+    filters: { ...rowFilters, ...columnFilters },
+    label: labelParts.join(" / ")
+  };
+}
+
+export { PIVOT_META_PROP, buildPivotColumns, buildPivotRendererModel, buildPivotRows, buildPivotTotalRow, formatPivotValue, initialPivotViewState, isPivotColumnGroup, nextPivotSort, pivotCellAction, pivotCellPresentation, pivotColumnFilters, pivotColumnGroups, pivotFilterCount, pivotFilterKeeps, pivotGroupKeys, pivotHasGroups, pivotHeatmapIntensity, pivotMeasuresByKey, pivotOpenColumnLevels, pivotOpenRowLevels, pivotRowFilters, pivotRowMeta, pivotSignature, pivotSortDirection, pivotTruncationNote, pivotValueColumns, pivotVisibleRows, readPivotPayload, setPivotColumnFilter, togglePivotGroup };
+//# sourceMappingURL=chunk-LHD445PJ.js.map
+//# sourceMappingURL=chunk-LHD445PJ.js.map