lightview 2.0.7 → 2.0.9

package/scripts/analysis/analyze.js

@@ -0,0 +1,266 @@
+const fs = require('fs');
+const acorn = require('acorn');
+const walk = require('acorn-walk');
+const path = require('path');
+
+/**
+ * 2025 LIGHTVIEW CODEBASE METRICS ENGINE
+ * Calculates:
+ * - Cyclomatic Complexity (Control Flow Paths)
+ * - Cognitive Complexity (2025 SonarSource Spec)
+ * - Halstead Volume (Operator/Operand Density)
+ * - SLOC (Source Lines of Code)
+ * - Maintainability Index (MI)
+ */
+
+const TARGET_FILES = [
+    '../../lightview.js',
+    '../../lightview-x.js',
+    '../../lightview-router.js',
+    '../../node_modules/react/cjs/react.development.js',
+    '../../node_modules/@grucloud/bau/bau.js',
+    '../../node_modules/htmx.org/dist/htmx.js',
+    '../../node_modules/juris/juris.js'
+];
+
+// --- METRIC CALCULATORS ---
+
+const getCyclomaticComplexity = (fnNode) => {
+    let complexity = 1;
+    walk.recursive(fnNode.body, null, {
+        IfStatement(node, state, c) { complexity++; c(node.test, state); c(node.consequent, state); if (node.alternate) c(node.alternate, state); },
+        ConditionalExpression(node, state, c) { complexity++; c(node.test, state); c(node.consequent, state); c(node.alternate, state); },
+        WhileStatement(node, state, c) { complexity++; c(node.test, state); c(node.body, state); },
+        DoWhileStatement(node, state, c) { complexity++; c(node.test, state); c(node.body, state); },
+        ForStatement(node, state, c) { complexity++; if (node.init) c(node.init, state); if (node.test) c(node.test, state); if (node.update) c(node.update, state); c(node.body, state); },
+        ForInStatement(node, state, c) { complexity++; c(node.left, state); c(node.right, state); c(node.body, state); },
+        ForOfStatement(node, state, c) { complexity++; c(node.left, state); c(node.right, state); c(node.body, state); },
+        LogicalExpression(node, state, c) {
+            if (node.operator === '&&' || node.operator === '||' || node.operator === '??') complexity++;
+            c(node.left, state); c(node.right, state);
+        },
+        SwitchCase(node, state, c) { if (node.test) complexity++; if (node.test) c(node.test, state); node.consequent.forEach(n => c(n, state)); },
+        CatchClause(node, state, c) { complexity++; if (node.param) c(node.param, state); c(node.body, state); },
+        FunctionDeclaration() { }, FunctionExpression() { }, ArrowFunctionExpression() { }
+    });
+    return complexity;
+};
+
+const getCognitiveComplexity = (fnNode, fnName) => {
+    let score = 0;
+    const findRecursion = (node) => {
+        let count = 0;
+        walk.simple(node, {
+            CallExpression(call) { if (call.callee.type === 'Identifier' && call.callee.name === fnName) count++; }
+        });
+        return count;
+    };
+    const traverse = (n, d) => {
+        if (!n) return 0;
+        let s = 0;
+        switch (n.type) {
+            case 'IfStatement':
+                s += (1 + d);
+                s += traverse(n.test, d);
+                s += traverse(n.consequent, d + 1);
+                if (n.alternate) {
+                    s += 1;
+                    if (n.alternate.type === 'IfStatement') s += traverseBranch(n.alternate, d);
+                    else s += traverse(n.alternate, d + 1);
+                }
+                break;
+            case 'SwitchStatement': s += (1 + d); n.cases.forEach(c => s += traverse(c, d + 1)); break;
+            case 'ForStatement': case 'ForInStatement': case 'ForOfStatement': case 'WhileStatement': case 'DoWhileStatement':
+                s += (1 + d); s += traverse(n.body, d + 1); break;
+            case 'CatchClause': s += (1 + d); s += traverse(n.body, d + 1); break;
+            case 'LogicalExpression': s += 1; break; // Naive: count each operator sequence as 1
+            case 'ConditionalExpression': s += 1; s += traverse(n.consequent, d + 1); s += traverse(n.alternate, d + 1); break;
+            case 'BreakStatement': case 'ContinueStatement': s += 1; break;
+            case 'FunctionDeclaration': case 'FunctionExpression': case 'ArrowFunctionExpression': break;
+            default:
+                for (const key in n) {
+                    const c = n[key];
+                    if (Array.isArray(c)) c.forEach(i => { if (i?.type) s += traverse(i, d); });
+                    else if (c?.type) s += traverse(c, d);
+                }
+        }
+        return s;
+    };
+    const traverseBranch = (n, d) => {
+        let s = 1; s += traverse(n.test, d); s += traverse(n.consequent, d + 1);
+        if (n.alternate) {
+            if (n.alternate.type === 'IfStatement') s += traverseBranch(n.alternate, d);
+            else { s += 1; s += traverse(n.alternate, d + 1); }
+        }
+        return s;
+    };
+    if (fnNode.body) {
+        score += traverse(fnNode.body, 0);
+        score += findRecursion(fnNode.body);
+    }
+    return score;
+};
+
+const calculateHalstead = (code) => {
+    let tokens = [];
+    try {
+        tokens = [...acorn.tokenizer(code, { ecmaVersion: 'latest' })];
+    } catch (e) {
+        // Fallback or skip if tokenization fails for complex files
+    }
+    const operators = new Set(['(', ')', '[', ']', '{', '}', '.', ',', ';', ':', '?', '...', '=', '+=', '-=', '*=', '/=', '==', '===', '!=', '!==', '<', '>', '<=', '>=', '+', '-', '*', '/', '%', '++', '--', '&&', '||', '??', '!', 'typeof', 'let', 'const', 'var', 'if', 'else', 'for', 'while', 'return']);
+    let N1 = 0, N2 = 0; const n1set = new Set(), n2set = new Set();
+    tokens.forEach(t => {
+        const txt = t.value !== undefined ? String(t.value) : t.type.label;
+        if (operators.has(txt)) { N1++; n1set.add(txt); } else { N2++; n2set.add(txt); }
+    });
+    const N = N1 + N2;
+    const n = n1set.size + n2set.size;
+    const volume = N * Math.log2(n || 1);
+    return { volume, n1: n1set.size, n2: n2set.size, N1, N2 };
+};
+
+const getSLOC = (code) => code.split('\n').filter(l => l.trim().length > 0 && !l.trim().startsWith('//')).length;
+
+const calculateMI = (volume, cc, sloc) => {
+    // Standard MI formula: 171 - 5.2 * ln(V) - 0.23 * CC - 16.2 * ln(SLOC)
+    const mi = 171 - 5.2 * Math.log(volume || 1) - 0.23 * cc - 16.2 * Math.log(sloc || 1);
+    return Math.max(0, Math.min(100, (mi * 100) / 171));
+};
+
+// --- ANALYSIS CORE ---
+
+const analyzeFile = (filePath) => {
+    const fullPath = path.resolve(__dirname, filePath);
+    if (!fs.existsSync(fullPath)) return { error: `File not found: ${filePath}` };
+
+    const code = fs.readFileSync(fullPath, 'utf8');
+    let ast;
+    try {
+        ast = acorn.parse(code, { ecmaVersion: 'latest', sourceType: 'script' });
+    } catch (e) {
+        try {
+            ast = acorn.parse(code, { ecmaVersion: 'latest', sourceType: 'module' });
+        } catch (e2) {
+            return { error: `AST Parse Error: ${e2.message}` };
+        }
+    }
+    const sloc = getSLOC(code);
+    const fileHalstead = calculateHalstead(code);
+
+    const fns = [];
+    walk.ancestor(ast, {
+        FunctionDeclaration(node) { fns.push({ node, name: node.id?.name || '<anonymous>' }); },
+        FunctionExpression(node, state, anc) {
+            let name = '<anonymous>';
+            const p = anc[anc.length - 2];
+            if (p?.type === 'VariableDeclarator' && p.id?.name) name = p.id.name;
+            else if (p?.type === 'Property' && p.key?.name) name = p.key.name;
+            else if (p?.type === 'AssignmentExpression' && p.left?.name) name = p.left.name;
+            fns.push({ node, name });
+        },
+        ArrowFunctionExpression(node, state, anc) {
+            let name = '<anonymous>';
+            const p = anc[anc.length - 2];
+            if (p?.type === 'VariableDeclarator' && p.id?.name) name = p.id.name;
+            fns.push({ node, name });
+        }
+    });
+
+    const results = fns.map(f => {
+        const cc = getCyclomaticComplexity(f.node);
+        const cog = getCognitiveComplexity(f.node, f.name);
+        const fCode = code.slice(f.node.start, f.node.end);
+        const h = calculateHalstead(fCode);
+        const fSloc = getSLOC(fCode);
+        const mi = calculateMI(h.volume, cc, fSloc);
+        return { name: f.name, cc, cog, mi, volume: h.volume, sloc: fSloc };
+    });
+
+    return {
+        fileName: path.basename(filePath),
+        sloc,
+        fnCount: fns.length,
+        totalVolume: fileHalstead.volume,
+        results
+    };
+};
+
+// --- REPORT GENERATION ---
+
+const generateReport = () => {
+    let md = "# Codebase Ethics & Complexity Report\n\n";
+    md += `Generated on: ${new Date().toLocaleString()}\n\n`;
+
+    const summaries = [];
+
+    TARGET_FILES.forEach(file => {
+        console.log(`Analyzing ${file}...`);
+        const data = analyzeFile(file);
+        if (data.error) {
+            md += `### !! Error analyzing ${file}: ${data.error}\n\n`;
+            summaries.push({
+                name: path.basename(file),
+                sloc: '-',
+                fns: '-',
+                mi: 'Error',
+                cog: 'Error',
+                status: "❌ Error"
+            });
+            return;
+        }
+
+        const miScores = data.results.map(r => r.mi);
+        const cogScores = data.results.map(r => r.cog);
+
+        const minMI = miScores.length ? Math.min(...miScores) : 0;
+        const avgMI = miScores.length ? miScores.reduce((a, b) => a + b, 0) / miScores.length : 0;
+        const maxMI = miScores.length ? Math.max(...miScores) : 0;
+
+        const minCog = cogScores.length ? Math.min(...cogScores) : 0;
+        const avgCog = cogScores.length ? cogScores.reduce((a, b) => a + b, 0) / cogScores.length : 0;
+        const maxCog = cogScores.length ? Math.max(...cogScores) : 0;
+
+        summaries.push({
+            name: data.fileName,
+            sloc: data.sloc,
+            fns: data.fnCount,
+            mi: `${minMI.toFixed(1)} / ${avgMI.toFixed(1)} / ${maxMI.toFixed(1)}`,
+            cog: `${minCog.toFixed(0)} / ${avgCog.toFixed(1)} / ${maxCog.toFixed(0)}`,
+            avgMI,
+            status: avgMI > 80 ? "✅ Excellent" : (avgMI > 65 ? "⚖️ Good" : "⚠️ Attention")
+        });
+
+        md += `## Detail: ${data.fileName}\n\n`;
+        md += `| Metric | Overall Value |\n| :--- | :--- |\n`;
+        md += `| **SLOC** | ${data.sloc} |\n`;
+        md += `| **Function Count** | ${data.fnCount} |\n`;
+        md += `| **Avg Maintainability** | **${avgMI.toFixed(2)}/100** |\n\n`;
+
+        md += `### Top 10 High Friction Functions\n`;
+        md += `| Function | Cognitive | Cyclomatic | MI | Status |\n| :--- | :--- | :--- | :--- | :--- |\n`;
+
+        data.results
+            .sort((a, b) => b.cog - a.cog)
+            .slice(0, 10)
+            .forEach(r => {
+                const status = r.cog > 25 ? "🛑 Critical" : (r.cog > 15 ? "⚠️ High" : "✅ Clean");
+                md += `| \`${r.name}\` | ${r.cog} | ${r.cc} | ${r.mi.toFixed(1)} | ${status} |\n`;
+            });
+
+        md += "\n---\n\n";
+    });
+
+    let summaryHeader = "## Executive Summary\n\n| File | Functions | Maintainability (min/avg/max) | Cognitive (min/avg/max) | Status |\n| :--- | :--- | :--- | :--- | :--- |\n";
+    summaries.sort((a, b) => {
+        // Optional: sort by status or name. Let's keep TARGET_FILES order if possible, or sort by name.
+        return 0; // Keep order of TARGET_FILES
+    }).forEach(s => {
+        summaryHeader += `| \`${s.name}\` | ${s.fns} | ${s.mi} | ${s.cog} | ${s.status} |\n`;
+    });
+
+    fs.writeFileSync(path.resolve(__dirname, 'latest_metrics.md'), md.replace("# Codebase Ethics & Complexity Report", "# Metrics Report\n\n" + summaryHeader));
+    console.log("Analysis complete. Report saved to latest_metrics.md");
+};
+
+generateReport();

package/scripts/analysis/latest_metrics.md

@@ -0,0 +1,185 @@
+# Metrics Report
+
+## Executive Summary
+
+| File | Functions | Maintainability (min/avg/max) | Cognitive (min/avg/max) | Status |
+| :--- | :--- | :--- | :--- | :--- |
+| `lightview.js` | 58 | 7.2 / 65.5 / 92.9 | 0 / 3.4 / 25 | ⚖️ Good |
+| `lightview-x.js` | 104 | 0.0 / 66.7 / 93.5 | 0 / 3.2 / 23 | ⚖️ Good |
+| `lightview-router.js` | 27 | 24.8 / 68.6 / 93.5 | 0 / 2.1 / 19 | ⚖️ Good |
+| `react.development.js` | 109 | 0.0 / 65.2 / 91.5 | 0 / 2.2 / 33 | ⚖️ Good |
+| `bau.js` | 79 | 11.2 / 71.3 / 92.9 | 0 / 1.5 / 20 | ⚖️ Good |
+| `htmx.js` | 335 | 0.0 / 65.3 / 92.9 | 0 / 3.4 / 116 | ⚖️ Good |
+| `juris.js` | 360 | 21.2 / 70.1 / 96.5 | 0 / 2.6 / 51 | ⚖️ Good |
+
+
+Generated on: 12/30/2025, 7:44:35 AM
+
+## Detail: lightview.js
+
+| Metric | Overall Value |
+| :--- | :--- |
+| **SLOC** | 599 |
+| **Function Count** | 58 |
+| **Avg Maintainability** | **65.52/100** |
+
+### Top 10 High Friction Functions
+| Function | Cognitive | Cyclomatic | MI | Status |
+| :--- | :--- | :--- | :--- | :--- |
+| `processChildren` | 25 | 19 | 35.1 | ⚠️ High |
+| `makeReactiveAttributes` | 19 | 12 | 38.8 | ⚠️ High |
+| `processComponentResult` | 17 | 15 | 42.0 | ⚠️ High |
+| `enhance` | 13 | 10 | 44.6 | ✅ Clean |
+| `value` | 11 | 11 | 44.2 | ✅ Clean |
+| `processShadowDOM` | 10 | 10 | 43.5 | ✅ Clean |
+| `signal` | 9 | 7 | 40.9 | ✅ Clean |
+| `<anonymous>` | 9 | 9 | 59.0 | ✅ Clean |
+| `<anonymous>` | 9 | 9 | 49.2 | ✅ Clean |
+| `<anonymous>` | 9 | 6 | 7.2 | ✅ Clean |
+
+---
+
+## Detail: lightview-x.js
+
+| Metric | Overall Value |
+| :--- | :--- |
+| **SLOC** | 1012 |
+| **Function Count** | 104 |
+| **Avg Maintainability** | **66.70/100** |
+
+### Top 10 High Friction Functions
+| Function | Cognitive | Cyclomatic | MI | Status |
+| :--- | :--- | :--- | :--- | :--- |
+| `<anonymous>` | 23 | 20 | 0.0 | ⚠️ High |
+| `state` | 22 | 25 | 39.6 | ⚠️ High |
+| `handleNonStandardHref` | 16 | 12 | 36.5 | ⚠️ High |
+| `registerStyleSheet` | 14 | 8 | 46.5 | ✅ Clean |
+| `removeInsertedContent` | 14 | 7 | 45.5 | ✅ Clean |
+| `convertObjectDOM` | 13 | 12 | 54.0 | ✅ Clean |
+| `<anonymous>` | 13 | 9 | 55.7 | ✅ Clean |
+| `activateReactiveSyntax` | 13 | 10 | 36.9 | ✅ Clean |
+| `<anonymous>` | 12 | 12 | 44.9 | ✅ Clean |
+| `handleSrcAttribute` | 10 | 9 | 47.1 | ✅ Clean |
+
+---
+
+## Detail: lightview-router.js
+
+| Metric | Overall Value |
+| :--- | :--- |
+| **SLOC** | 141 |
+| **Function Count** | 27 |
+| **Avg Maintainability** | **68.59/100** |
+
+### Top 10 High Friction Functions
+| Function | Cognitive | Cyclomatic | MI | Status |
+| :--- | :--- | :--- | :--- | :--- |
+| `route` | 19 | 10 | 51.6 | ⚠️ High |
+| `normalizePath` | 7 | 8 | 63.1 | ✅ Clean |
+| `<anonymous>` | 5 | 6 | 50.2 | ✅ Clean |
+| `handleRequest` | 5 | 6 | 52.6 | ✅ Clean |
+| `fetchHandler` | 4 | 4 | 64.3 | ✅ Clean |
+| `<anonymous>` | 4 | 4 | 24.8 | ✅ Clean |
+| `base` | 2 | 3 | 65.1 | ✅ Clean |
+| `<anonymous>` | 2 | 4 | 84.4 | ✅ Clean |
+| `use` | 2 | 3 | 63.6 | ✅ Clean |
+| `<anonymous>` | 2 | 4 | 64.7 | ✅ Clean |
+
+---
+
+## Detail: react.development.js
+
+| Metric | Overall Value |
+| :--- | :--- |
+| **SLOC** | 1282 |
+| **Function Count** | 109 |
+| **Avg Maintainability** | **65.19/100** |
+
+### Top 10 High Friction Functions
+| Function | Cognitive | Cyclomatic | MI | Status |
+| :--- | :--- | :--- | :--- | :--- |
+| `mapIntoArray` | 33 | 39 | 23.6 | 🛑 Critical |
+| `getComponentNameFromType` | 20 | 31 | 34.7 | ⚠️ High |
+| `flushActQueue` | 19 | 7 | 47.0 | ⚠️ High |
+| `<anonymous>` | 19 | 26 | 35.6 | ⚠️ High |
+| `<anonymous>` | 18 | 20 | 35.9 | ⚠️ High |
+| `lazyInitializer` | 9 | 9 | 37.7 | ✅ Clean |
+| `recursivelyFlushAsyncActWork` | 9 | 5 | 51.3 | ✅ Clean |
+| `<anonymous>` | 8 | 9 | 48.2 | ✅ Clean |
+| `<anonymous>` | 7 | 10 | 29.6 | ✅ Clean |
+| `<anonymous>` | 7 | 10 | 0.0 | ✅ Clean |
+
+---
+
+## Detail: bau.js
+
+| Metric | Overall Value |
+| :--- | :--- |
+| **SLOC** | 458 |
+| **Function Count** | 79 |
+| **Avg Maintainability** | **71.26/100** |
+
+### Top 10 High Friction Functions
+| Function | Cognitive | Cyclomatic | MI | Status |
+| :--- | :--- | :--- | :--- | :--- |
+| `<anonymous>` | 20 | 17 | 34.0 | ⚠️ High |
+| `updateBinding` | 17 | 11 | 40.0 | ⚠️ High |
+| `replaceChildren` | 14 | 8 | 48.2 | ✅ Clean |
+| `add` | 9 | 7 | 53.3 | ✅ Clean |
+| `toDom` | 6 | 5 | 56.8 | ✅ Clean |
+| `get` | 5 | 6 | 49.4 | ✅ Clean |
+| `processDom` | 4 | 4 | 51.1 | ✅ Clean |
+| `val` | 4 | 5 | 58.1 | ✅ Clean |
+| `val` | 4 | 4 | 55.4 | ✅ Clean |
+| `<anonymous>` | 3 | 6 | 49.7 | ✅ Clean |
+
+---
+
+## Detail: htmx.js
+
+| Metric | Overall Value |
+| :--- | :--- |
+| **SLOC** | 4803 |
+| **Function Count** | 335 |
+| **Avg Maintainability** | **65.27/100** |
+
+### Top 10 High Friction Functions
+| Function | Cognitive | Cyclomatic | MI | Status |
+| :--- | :--- | :--- | :--- | :--- |
+| `issueAjaxRequest` | 116 | 73 | 5.5 | 🛑 Critical |
+| `parseAndCacheTrigger` | 68 | 34 | 28.0 | 🛑 Critical |
+| `doSwap` | 41 | 24 | 26.8 | 🛑 Critical |
+| `eventListener` | 39 | 22 | 33.2 | 🛑 Critical |
+| `handleAjaxResponse` | 34 | 29 | 22.9 | 🛑 Critical |
+| `querySelectorAllExt` | 33 | 26 | 31.9 | 🛑 Critical |
+| `swapWithStyle` | 29 | 16 | 38.3 | 🛑 Critical |
+| `updateScrollState` | 27 | 23 | 39.3 | 🛑 Critical |
+| `maybeGenerateConditional` | 26 | 9 | 42.0 | 🛑 Critical |
+| `getSwapSpecification` | 25 | 19 | 36.1 | ⚠️ High |
+
+---
+
+## Detail: juris.js
+
+| Metric | Overall Value |
+| :--- | :--- |
+| **SLOC** | 2736 |
+| **Function Count** | 360 |
+| **Avg Maintainability** | **70.11/100** |
+
+### Top 10 High Friction Functions
+| Function | Cognitive | Cyclomatic | MI | Status |
+| :--- | :--- | :--- | :--- | :--- |
+| `<anonymous>` | 51 | 28 | 21.2 | 🛑 Critical |
+| `<anonymous>` | 37 | 33 | 26.4 | 🛑 Critical |
+| `<anonymous>` | 36 | 28 | 31.2 | 🛑 Critical |
+| `<anonymous>` | 24 | 14 | 43.2 | ⚠️ High |
+| `<anonymous>` | 24 | 26 | 28.7 | ⚠️ High |
+| `<anonymous>` | 22 | 12 | 44.1 | ⚠️ High |
+| `<anonymous>` | 20 | 8 | 49.5 | ⚠️ High |
+| `updateChildren` | 19 | 11 | 37.4 | ⚠️ High |
+| `<anonymous>` | 18 | 23 | 38.6 | ⚠️ High |
+| `<anonymous>` | 17 | 9 | 46.3 | ⚠️ High |
+
+---
+

package/wrangler.toml

@@ -1,6 +1,10 @@
 name = "lightview"
 compatibility_date = "2024-01-01"
 
+# Enable eval() and new Function() for SSR script processing
+[unsafe]
+eval = true
+
 # [build]
 # command = "npm run build"
 
@@ -8,5 +12,7 @@ compatibility_date = "2024-01-01"
 # Note: Static asset headers are now defined in _headers file
 # and the build directory is specified in the deploy command or dashboard.
 
+# Assets directory is set via the `wrangler pages dev <directory>` command
+# Uncomment below for Workers mode (not Pages mode):
 [assets]
 directory = "./dist"