@prolibu-suite/cobalt-core 0.1.2 → 0.2.0

package/dist/collection/components/co-column-picker/column-picker-node.js

@@ -0,0 +1,34 @@
+/**
+ * Stencil FunctionalComponent for rendering a single tree node
+ * in the column-picker dropdown.
+ */
+import { h } from "@stencil/core";
+import { collectAllLeafPaths, formatLabel, highlightLabel } from "./utils/column-picker-tree";
+export const ColumnPickerNode = (props) => {
+    const { node, depth, selected, expandedKeys, disabled, query, onOptionClick, onParentCheck, onToggleExpand } = props;
+    const isLeaf = !node.children || node.children.length === 0;
+    const isExpanded = expandedKeys.has(node.key);
+    const isSelected = isLeaf && selected.includes(node.fullPath);
+    let allChildrenSelected = false;
+    let someChildrenSelected = false;
+    let selectedChildCount = 0;
+    let totalLeafCount = 0;
+    if (!isLeaf && node.children) {
+        const lp = collectAllLeafPaths(node.children);
+        totalLeafCount = lp.length;
+        selectedChildCount = lp.filter(p => selected.includes(p)).length;
+        allChildrenSelected = totalLeafCount > 0 && selectedChildCount === totalLeafCount;
+        someChildrenSelected = selectedChildCount > 0;
+    }
+    return (h("div", { class: "co-column-picker__node" }, h("div", { class: {
+            'co-column-picker__node-row': true,
+            'co-column-picker__node-row--leaf': isLeaf,
+            'co-column-picker__node-row--parent': !isLeaf,
+            'co-column-picker__node-row--expanded': !isLeaf && isExpanded,
+            'co-column-picker__node-row--selected': isLeaf && isSelected,
+        }, style: { paddingLeft: `${depth * 20 + 10}px` }, onClick: (e) => isLeaf ? onOptionClick(node.fullPath) : onToggleExpand(node.key, e) }, h("co-checkbox", { checked: isLeaf ? isSelected : allChildrenSelected, indeterminate: !isLeaf && someChildrenSelected && !allChildrenSelected, disabled: disabled, onClick: (e) => { e.stopPropagation(); isLeaf ? onOptionClick(node.fullPath) : onParentCheck(node); } }), h("span", { class: {
+            'co-column-picker__node-label': true,
+            'co-column-picker__node-label--parent': !isLeaf,
+            'co-column-picker__node-label--self': !!node.isSelf,
+        }, innerHTML: highlightLabel(formatLabel(node.label), query) }), node.isSelf && h("span", { class: "co-column-picker__self-tag" }, "self"), !isLeaf && (h("span", { class: "co-column-picker__node-counter" }, selectedChildCount > 0 && [h("span", { class: "co-column-picker__counter-selected" }, selectedChildCount), h("span", { class: "co-column-picker__counter-sep" }, "/")], h("span", { class: "co-column-picker__counter-total" }, totalLeafCount))), !isLeaf && (h("span", { class: { 'co-column-picker__chevron': true, 'co-column-picker__chevron--open': isExpanded }, onClick: (e) => onToggleExpand(node.key, e) }, h("co-icon", { name: "caret-right", size: 16 })))), !isLeaf && isExpanded && node.children && (h("div", { class: "co-column-picker__node-children", style: { '--guide-left': `${depth * 20 + 19}px` } }, node.children.map(child => (h(ColumnPickerNode, { node: child, depth: depth + 1, selected: selected, expandedKeys: expandedKeys, disabled: disabled, query: query, onOptionClick: onOptionClick, onParentCheck: onParentCheck, onToggleExpand: onToggleExpand })))))));
+};

package/dist/collection/components/co-column-picker/utils/column-picker-tree.js

@@ -0,0 +1,221 @@
+/**
+ * Pure tree-building, filtering, and string utilities for co-column-picker.
+ * No Stencil dependency — fully unit-testable.
+ */
+import { normalizeText as normalize } from "../../../utils/normalizeText";
+// ── JSON parse helpers ─────────────────────────────────────────
+export function parsePaths(raw) {
+    let parsed = raw;
+    if (typeof parsed === 'string') {
+        try {
+            parsed = JSON.parse(parsed);
+        }
+        catch (_a) {
+            return [];
+        }
+    }
+    if (!Array.isArray(parsed))
+        return [];
+    return parsed.map(item => typeof item === 'string' ? item : item.value);
+}
+export function parseSections(raw) {
+    let parsed = raw;
+    if (typeof parsed === 'string') {
+        try {
+            parsed = JSON.parse(parsed);
+        }
+        catch (_a) {
+            return [];
+        }
+    }
+    return Array.isArray(parsed) ? parsed : [];
+}
+export function parseValues(raw) {
+    if (typeof raw === 'string') {
+        try {
+            return JSON.parse(raw);
+        }
+        catch (_a) {
+            return raw ? [raw] : [];
+        }
+    }
+    return Array.isArray(raw) ? raw : [];
+}
+export function buildLabelMap(raw) {
+    let parsed = raw;
+    if (typeof parsed === 'string') {
+        try {
+            parsed = JSON.parse(parsed);
+        }
+        catch (_a) {
+            return new Map();
+        }
+    }
+    if (!Array.isArray(parsed))
+        return new Map();
+    const map = new Map();
+    for (const item of parsed) {
+        if (typeof item === 'string') {
+            map.set(item, formatLabel(item.split('.').pop() || item));
+        }
+        else {
+            const o = item;
+            map.set(o.value, o.label || o.value);
+        }
+    }
+    return map;
+}
+// ── String utilities ───────────────────────────────────────────
+// Re-exported (aliased) from the shared util — keeps this module's public API
+// (`normalize`) stable while using the single source of truth.
+export { normalize };
+export function formatLabel(str) {
+    if (!str)
+        return '';
+    return str.replace(/([a-z])([A-Z])/g, '$1 $2').replace(/[_-]+/g, ' ').replace(/^\w/, c => c.toUpperCase());
+}
+export function escapeHtml(str) {
+    return String(str).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+export function highlightLabel(text, search) {
+    if (!search)
+        return escapeHtml(text);
+    const escaped = search.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return escapeHtml(text).replace(new RegExp(`(${escaped})`, 'gi'), '<mark>$1</mark>');
+}
+// ── Tree building ──────────────────────────────────────────────
+export function buildTree(flatPaths, labelMap) {
+    const pathSet = new Set(flatPaths);
+    const rootMap = {};
+    for (const path of flatPaths) {
+        const parts = path.split('.');
+        let currentMap = rootMap;
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            const key = parts.slice(0, i + 1).join('.');
+            if (!currentMap[part]) {
+                const isLeaf = i === parts.length - 1;
+                const nodeLabel = (isLeaf && (labelMap === null || labelMap === void 0 ? void 0 : labelMap.get(key))) || part;
+                currentMap[part] = { label: nodeLabel, key, childrenMap: {} };
+            }
+            if (i < parts.length - 1) {
+                currentMap = currentMap[part].childrenMap;
+            }
+        }
+    }
+    const mapToArray = (map) => {
+        return Object.values(map).map((node) => {
+            const children = mapToArray(node.childrenMap);
+            const hasChildren = children.length > 0;
+            const isSelfSelectable = hasChildren && pathSet.has(node.key);
+            const result = { label: node.label, key: node.key, fullPath: node.key, children: hasChildren ? children : null };
+            if (isSelfSelectable && result.children) {
+                result.children.unshift({ label: node.label, key: node.key + '.__self', fullPath: node.key, children: null, isSelf: true });
+            }
+            return result;
+        });
+    };
+    return sortNodes(mapToArray(rootMap));
+}
+export function sortNodes(nodes) {
+    return [...nodes]
+        .sort((a, b) => {
+        if (a.isSelf)
+            return -1;
+        if (b.isSelf)
+            return 1;
+        const aP = a.children && a.children.length > 0;
+        const bP = b.children && b.children.length > 0;
+        if (!aP && bP)
+            return -1;
+        if (aP && !bP)
+            return 1;
+        return a.label.localeCompare(b.label);
+    })
+        .map(node => (Object.assign(Object.assign({}, node), { children: node.children ? sortNodes(node.children) : null })));
+}
+export function filterTree(nodes, q) {
+    const nq = normalize(q);
+    return nodes
+        .map(node => {
+        const labelMatch = normalize(node.label).includes(nq);
+        const formattedMatch = normalize(formatLabel(node.label)).includes(nq);
+        const pathMatch = normalize(node.fullPath).includes(nq);
+        if (!node.children || node.children.length === 0) {
+            return (labelMatch || formattedMatch || pathMatch) ? node : null;
+        }
+        const filteredChildren = filterTree(node.children, q);
+        if (labelMatch || formattedMatch || filteredChildren.length > 0) {
+            return Object.assign(Object.assign({}, node), { children: filteredChildren.length > 0 ? filteredChildren : node.children });
+        }
+        return null;
+    })
+        .filter(Boolean);
+}
+export function collectAllLeafPaths(nodes) {
+    const paths = [];
+    for (const node of nodes) {
+        if (!node.children || node.children.length === 0)
+            paths.push(node.fullPath);
+        else
+            paths.push(...collectAllLeafPaths(node.children));
+    }
+    return paths;
+}
+// ── Auto-expand ────────────────────────────────────────────────
+export function expandForSelected(tree, selected, current) {
+    if (!selected.length)
+        return current;
+    const keys = new Set(current);
+    const walk = (nodes) => {
+        var _a;
+        for (const n of nodes) {
+            if ((_a = n.children) === null || _a === void 0 ? void 0 : _a.length) {
+                if (collectAllLeafPaths(n.children).some(p => selected.includes(p)))
+                    keys.add(n.key);
+                walk(n.children);
+            }
+        }
+    };
+    walk(tree);
+    return keys;
+}
+export function expandForQuery(nodes, q, current) {
+    const nq = normalize(q);
+    const keys = new Set(current);
+    const walk = (ns) => {
+        var _a;
+        let any = false;
+        for (const n of ns) {
+            if ((_a = n.children) === null || _a === void 0 ? void 0 : _a.length) {
+                const cm = walk(n.children);
+                const sm = normalize(n.label).includes(nq) || normalize(formatLabel(n.label)).includes(nq);
+                if (cm || sm) {
+                    keys.add(n.key);
+                    any = true;
+                }
+            }
+            else {
+                if (normalize(n.label).includes(nq) || normalize(formatLabel(n.label)).includes(nq))
+                    any = true;
+            }
+        }
+        return any;
+    };
+    walk(nodes);
+    return keys;
+}
+export function collectAllExpandableKeys(nodes) {
+    const keys = new Set();
+    const walk = (ns) => {
+        var _a;
+        for (const n of ns) {
+            if ((_a = n.children) === null || _a === void 0 ? void 0 : _a.length) {
+                keys.add(n.key);
+                walk(n.children);
+            }
+        }
+    };
+    walk(nodes);
+    return keys;
+}