fix(cpp.js): make config list output readable

`config list -t project` passed the fully-resolved, deeply-nested config
object straight to console.table, which created one column per nested
sub-key — an unreadable 60+ column table.

Flatten it into a two-column dotted-key view instead: paths shown
relative to base, long values middle-truncated, dependency arrays shown
as names, and large per-target maps (allDependencyPaths) collapsed to
their keys.

Author: bugra9

cppjs-core/cpp.js/src/bin.js

@@ -15,6 +15,7 @@ import { getBuildTargets, getFilteredBuildTargets, getFilteredTargetSpec } from
 
 import downloadAndExtractFile from './utils/downloadAndExtractFile.js';
 import writeJson from './utils/writeJson.js';
+import flattenConfigForTable from './utils/flattenConfigForTable.js';
 import systemKeys from './utils/systemKeys.js';
 import logger from './utils/logger.js';
 import { getDockerImage } from './utils/pullDockerImage.js';
@@ -197,8 +198,8 @@ function listSystemConfig(type) {
     }
 
     if (type === 'all' || type === 'project') {
-        console.log('Project Configuration');
-        console.table(projectConfig);
+        console.log(`Project Configuration (paths relative to ${projectConfig.paths.base})`);
+        console.table(flattenConfigForTable(projectConfig, { base: projectConfig.paths.base }));
     }
 }
 

cppjs-core/cpp.js/src/utils/flattenConfigForTable.js

@@ -0,0 +1,75 @@
+const isPlainObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+
+// Object maps with at least this many object-valued entries (e.g. allDependencyPaths,
+// keyed per target) collapse to their key list instead of exploding into rows.
+const LARGE_MAP_MIN_KEYS = 8;
+
+function relativizePath(value, base) {
+    if (base && typeof value === 'string' && value.startsWith(`${base}/`)) {
+        return value.slice(base.length + 1);
+    }
+    return value;
+}
+
+function truncateMiddle(value, max) {
+    if (typeof value !== 'string' || value.length <= max) return value;
+    const head = Math.ceil((max - 1) / 2);
+    const tail = Math.floor((max - 1) / 2);
+    return `${value.slice(0, head)}…${value.slice(value.length - tail)}`;
+}
+
+function formatScalar(value, base, maxLen) {
+    if (typeof value === 'function') return '[Function]';
+    if (typeof value === 'string') return truncateMiddle(relativizePath(value, base), maxLen);
+    return value;
+}
+
+// Flattens a resolved cpp.js config into a { 'dotted.key': displayValue } map so
+// console.table renders a readable two-column view instead of one column per
+// nested sub-key. Paths are shown relative to base and long values truncated in
+// the middle; dependency arrays collapse to names, large per-target maps collapse
+// to their keys, and other structures recurse with dotted/indexed keys.
+export default function flattenConfigForTable(config, { base = null, maxDepth = 5, maxValueLength = 80 } = {}) {
+    const out = {};
+
+    const walk = (value, prefix, depth) => {
+        if (Array.isArray(value)) {
+            if (value.length === 0) {
+                out[prefix] = '[]';
+            } else if (value.every((v) => v === null || typeof v !== 'object')) {
+                out[prefix] = truncateMiddle(value.map((v) => relativizePath(v, base)).join(', '), maxValueLength);
+            } else {
+                const names = value.map((v) => v?.general?.name ?? v?.package?.name).filter(Boolean);
+                if (names.length === value.length) {
+                    out[prefix] = names.join(', ');
+                } else if (depth <= 0) {
+                    out[prefix] = `<${value.length} items>`;
+                } else {
+                    value.forEach((v, i) => walk(v, `${prefix}.${i}`, depth - 1));
+                }
+            }
+            return;
+        }
+
+        if (!isPlainObject(value)) {
+            out[prefix] = formatScalar(value, base, maxValueLength);
+            return;
+        }
+
+        const keys = Object.keys(value);
+        const isLargeObjectMap = prefix !== '' && keys.length >= LARGE_MAP_MIN_KEYS
+            && keys.every((k) => isPlainObject(value[k]));
+        if (keys.length === 0) {
+            out[prefix] = '{}';
+        } else if (isLargeObjectMap) {
+            out[prefix] = truncateMiddle(keys.join(', '), maxValueLength);
+        } else if (depth <= 0) {
+            out[prefix] = '{…}';
+        } else {
+            keys.forEach((k) => walk(value[k], prefix ? `${prefix}.${k}` : k, depth - 1));
+        }
+    };
+
+    walk(config, '', maxDepth);
+    return out;
+}

cppjs-core/cpp.js/test/flattenConfigForTable.test.js

@@ -0,0 +1,97 @@
+import { describe, test, expect } from 'vitest';
+import flattenConfigForTable from '../src/utils/flattenConfigForTable.js';
+
+describe('flattenConfigForTable', () => {
+    test('flattens nested objects into dotted keys', () => {
+        const out = flattenConfigForTable({ general: { name: 'app', alias: { package: 'gdal3.js' } } });
+        expect(out['general.name']).toBe('app');
+        expect(out['general.alias.package']).toBe('gdal3.js');
+    });
+
+    test('joins arrays of primitives inline', () => {
+        const out = flattenConfigForTable({ ext: { header: ['h', 'hpp', 'hxx'] } });
+        expect(out['ext.header']).toBe('h, hpp, hxx');
+    });
+
+    test('collapses arrays of dependency objects to their names', () => {
+        const out = flattenConfigForTable({
+            allDependencies: [{ general: { name: 'gdal' } }, { package: { name: '@cpp.js/package-proj' } }],
+        });
+        expect(out.allDependencies).toBe('gdal, @cpp.js/package-proj');
+    });
+
+    test('recurses arrays of nameless objects into indexed keys', () => {
+        const out = flattenConfigForTable({ targetSpecs: [{ specs: { env: { FOO: '1' } } }] });
+        expect(out['targetSpecs.0.specs.env.FOO']).toBe('1');
+    });
+
+    test('summarizes nameless object arrays once depth is exhausted', () => {
+        const out = flattenConfigForTable({ targetSpecs: [{ specs: {} }, { specs: {} }] }, { maxDepth: 1 });
+        expect(out.targetSpecs).toBe('<2 items>');
+    });
+
+    test('renders functions as [Function]', () => {
+        const out = flattenConfigForTable({ functions: { isEnabled: () => true } });
+        expect(out['functions.isEnabled']).toBe('[Function]');
+    });
+
+    test('shows keys for large maps of objects instead of expanding them', () => {
+        const targets = {};
+        for (let i = 0; i < 10; i += 1) targets[`t${i}`] = { gdal: { root: '/x' } };
+        const out = flattenConfigForTable({ allDependencyPaths: targets });
+        expect(out.allDependencyPaths).toContain('t0');
+        expect(out['allDependencyPaths.t0']).toBeUndefined();
+        expect(out['allDependencyPaths.t0.gdal']).toBeUndefined();
+    });
+
+    test('recurses small maps of objects to show their contents', () => {
+        const out = flattenConfigForTable({ specs: { env: { FOO: '1', BAR: '2' } } });
+        expect(out['specs.env.FOO']).toBe('1');
+        expect(out['specs.env.BAR']).toBe('2');
+    });
+
+    test('caps nesting depth to keep output terse', () => {
+        const out = flattenConfigForTable({ a: { b: { c: { d: 1 } } } }, { maxDepth: 2 });
+        expect(out['a.b']).toBe('{…}');
+        expect(out['a.b.c']).toBeUndefined();
+    });
+
+    test('marks empty objects and arrays', () => {
+        const out = flattenConfigForTable({ build: {}, binHeaders: [] });
+        expect(out.build).toBe('{}');
+        expect(out.binHeaders).toBe('[]');
+    });
+
+    test('relativizes absolute paths under base, leaving outside paths absolute', () => {
+        const out = flattenConfigForTable(
+            { paths: { native: '/repo/packages/core/native', systemConfig: '/home/u/.cppjs.json' } },
+            { base: '/repo' },
+        );
+        expect(out['paths.native']).toBe('packages/core/native');
+        expect(out['paths.systemConfig']).toBe('/home/u/.cppjs.json');
+    });
+
+    test('relativizes each entry of an absolute-path array (globs)', () => {
+        const out = flattenConfigForTable(
+            { dependencyParameters: { nativeGlob: ['/repo/src/*.c', '/repo/src/*.cpp'] } },
+            { base: '/repo' },
+        );
+        expect(out['dependencyParameters.nativeGlob']).toBe('src/*.c, src/*.cpp');
+    });
+
+    test('truncates long values in the middle, preserving head and tail', () => {
+        const long = `/repo/${'x'.repeat(100)}/CMakeLists.txt`;
+        const out = flattenConfigForTable({ paths: { cmake: long } }, { base: '/repo', maxValueLength: 40 });
+        const value = out['paths.cmake'];
+        expect(value.length).toBe(40);
+        expect(value).toContain('…');
+        expect(value.endsWith('CMakeLists.txt')).toBe(true);
+    });
+
+    test('never truncates the dependency name list', () => {
+        const deps = Array.from({ length: 20 }, (_, i) => ({ general: { name: `dep${i}` } }));
+        const out = flattenConfigForTable({ allDependencies: deps }, { maxValueLength: 20 });
+        expect(out.allDependencies).toContain('dep19');
+        expect(out.allDependencies).not.toContain('…');
+    });
+});