@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-WA3OVISZ.mjs

@@ -0,0 +1,179 @@
+// src/utils/specialized/drilldown.utils.ts
+function buildDrilldownTree(data, idField, parentField, valueField) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < data.length; i++) {
+    const item = data[i];
+    const rec = item;
+    const id = String(rec[idField] ?? i);
+    const parentId = rec[parentField] != null ? String(rec[parentField]) : null;
+    const value = Number(rec[valueField]) || 0;
+    nodeMap.set(id, {
+      id,
+      parentId,
+      data: item,
+      index: i,
+      depth: 0,
+      children: [],
+      aggregateValue: value
+    });
+  }
+  const roots = [];
+  for (const node of nodeMap.values()) {
+    if (node.parentId && nodeMap.has(node.parentId)) {
+      nodeMap.get(node.parentId).children.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+  let maxDepth = 0;
+  function setDepth(node, depth) {
+    node.depth = depth;
+    if (depth > maxDepth) maxDepth = depth;
+    for (const child of node.children) {
+      setDepth(child, depth + 1);
+    }
+  }
+  function computeAggregate(node) {
+    if (node.children.length === 0) {
+      return node.aggregateValue;
+    }
+    let childSum = 0;
+    for (const child of node.children) {
+      childSum += computeAggregate(child);
+    }
+    if (node.aggregateValue === 0) {
+      node.aggregateValue = childSum;
+    }
+    return node.aggregateValue;
+  }
+  for (const root of roots) {
+    setDepth(root, 0);
+    computeAggregate(root);
+  }
+  return { nodeMap, roots, maxDepth };
+}
+function getChildren(tree, parentId) {
+  if (parentId === null) {
+    return tree.roots;
+  }
+  const node = tree.nodeMap.get(parentId);
+  return node ? node.children : [];
+}
+function getAncestorPath(tree, nodeId, categoryField) {
+  const path = [];
+  let current = tree.nodeMap.get(nodeId);
+  while (current) {
+    const label = categoryField ? String(current.data[categoryField] ?? current.id) : current.id;
+    path.unshift({ id: current.id, label });
+    current = current.parentId ? tree.nodeMap.get(current.parentId) : void 0;
+  }
+  return path;
+}
+function isParentNode(tree, nodeId) {
+  const node = tree.nodeMap.get(nodeId);
+  return node ? node.children.length > 0 : false;
+}
+function getLeaves(node) {
+  if (node.children.length === 0) return [node];
+  const leaves = [];
+  for (const child of node.children) {
+    if (child.children.length === 0) {
+      leaves.push(child);
+    } else {
+      leaves.push(...getLeaves(child));
+    }
+  }
+  return leaves;
+}
+function createDrilldownState(rootLabel = "All") {
+  return {
+    currentId: null,
+    path: [{ id: null, label: rootLabel }],
+    depth: 0
+  };
+}
+function drillInto(state, tree, nodeId, categoryField) {
+  const node = tree.nodeMap.get(nodeId);
+  if (!node || node.children.length === 0) return state;
+  const label = categoryField ? String(node.data[categoryField] ?? node.id) : node.id;
+  return {
+    currentId: nodeId,
+    path: [...state.path, { id: nodeId, label }],
+    depth: state.depth + 1
+  };
+}
+function drillUp(state) {
+  if (state.path.length <= 1) return state;
+  const newPath = state.path.slice(0, -1);
+  const parent = newPath[newPath.length - 1];
+  return {
+    currentId: parent.id,
+    path: newPath,
+    depth: state.depth - 1
+  };
+}
+function drillToLevel(state, index) {
+  if (index < 0 || index >= state.path.length) return state;
+  const newPath = state.path.slice(0, index + 1);
+  const target = newPath[newPath.length - 1];
+  return {
+    currentId: target.id,
+    path: newPath,
+    depth: index
+  };
+}
+function drillToRoot(state) {
+  return {
+    currentId: null,
+    path: [state.path[0]],
+    depth: 0
+  };
+}
+function isDrilldownEnabled(datasets) {
+  for (const [, ds] of datasets) {
+    if (ds.type === "treemap") {
+      const p = ds.props;
+      if (p.drilldown && p.nodeId && p.parentField) return true;
+    }
+  }
+  return false;
+}
+function getDrilldownRootLabel(datasets) {
+  for (const [, ds] of datasets) {
+    if (ds.type === "treemap") {
+      const p = ds.props;
+      if (p.rootLabel) return p.rootLabel;
+    }
+  }
+  return "All";
+}
+function buildAncestorChain(nodeId, layouts, currentParentId) {
+  for (const [, { props }] of layouts) {
+    if (!props.nodeId || !props.parentField || !props.data) continue;
+    const nodeInfo = /* @__PURE__ */ new Map();
+    for (const item of props.data) {
+      const rec = item;
+      const id = String(rec[props.nodeId] ?? "");
+      const pid = rec[props.parentField];
+      const lbl = String(rec[props.categoryField ?? ""] ?? id);
+      nodeInfo.set(id, { parentId: pid != null ? String(pid) : null, label: lbl });
+    }
+    const ancestors = [];
+    let current = nodeInfo.get(nodeId)?.parentId ?? null;
+    while (current !== null) {
+      const info = nodeInfo.get(current);
+      if (!info) break;
+      if (current === currentParentId) break;
+      if (info.parentId === currentParentId) {
+        ancestors.unshift({ id: current, label: info.label });
+        break;
+      }
+      ancestors.unshift({ id: current, label: info.label });
+      current = info.parentId;
+    }
+    return ancestors;
+  }
+  return [];
+}
+
+export { buildAncestorChain, buildDrilldownTree, createDrilldownState, drillInto, drillToLevel, drillToRoot, drillUp, getAncestorPath, getChildren, getDrilldownRootLabel, getLeaves, isDrilldownEnabled, isParentNode };