juxscript 1.1.281 → 1.1.282

package/machinery/autowrap.js

@@ -39,29 +39,6 @@ function containsPageStateRef(node) {
     return found;
 }
 
-function containsJuxCall(node) {
-    let found = false;
-    walkSimple(node, {
-        CallExpression(n) { if (n.callee?.object?.name === 'jux') found = true; }
-    });
-    return found;
-}
-
-function getDeclaredVarNames(stmt) {
-    if (stmt.type !== 'VariableDeclaration') return [];
-    return stmt.declarations
-        .filter(d => d.id.type === 'Identifier')
-        .map(d => d.id.name);
-}
-
-function usesIdentifier(node, name) {
-    let found = false;
-    walkSimple(node, {
-        Identifier(n) { if (n.name === name) found = true; }
-    });
-    return found;
-}
-
 function isAlreadyWrapped(stmt) {
     return stmt.type === 'ExpressionStatement' &&
         stmt.expression?.type === 'CallExpression' &&
@@ -69,36 +46,10 @@ function isAlreadyWrapped(stmt) {
         stmt.expression?.callee?.property?.name === '__watch';
 }
 
-/**
- * Extract the body statements from an existing __watch callback.
- * Returns null if the statement is not a __watch or has no block body.
- */
-function getWatchBody(stmt) {
-    if (!isAlreadyWrapped(stmt)) return null;
-    const arg = stmt.expression.arguments?.[0];
-    if (!arg) return null;
-    if (arg.type === 'ArrowFunctionExpression' || arg.type === 'FunctionExpression') {
-        if (arg.body?.type === 'BlockStatement') {
-            return arg.body.body; // array of statements
-        }
-    }
-    return null;
-}
-
-function isSetupStatement(stmt) {
-    // Never treat statements referencing pageState as setup
-    if (containsPageStateRef(stmt)) return false;
-
+function isSetupOnly(stmt) {
+    // Statements that should stay outside __watch
     if (stmt.type === 'ImportDeclaration') return true;
     if (stmt.type === 'FunctionDeclaration') return true;
-    if (stmt.type === 'ExpressionStatement') {
-        const expr = stmt.expression;
-        if (expr.type === 'CallExpression' &&
-            expr.callee?.object?.name === 'jux') return true;
-        if (expr.type === 'AwaitExpression' &&
-            expr.argument?.callee?.object?.name === 'jux') return true;
-    }
-    if (stmt.type === 'VariableDeclaration') return true;
     return false;
 }
 
@@ -124,186 +75,68 @@ export function autowrap(source, filename = '') {
             allowAwaitOutsideFunction: true,
         });
     } catch (err) {
-        // Can't parse — return as-is
         return { code: source, wrappedCount: 0, details: [`parse error: ${err.message}`] };
     }
 
-    const needsWatch = [];
-    let i = 0;
+    // Check if there are any unwrapped pageState references at all
+    let hasUnwrappedPageState = false;
+    let firstUnwrappedIdx = -1;
+    let lastUnwrappedIdx = -1;
 
-    while (i < ast.body.length) {
+    for (let i = 0; i < ast.body.length; i++) {
         const stmt = ast.body[i];
-
-        if (isSetupStatement(stmt)) { i++; continue; }
-
-        // Check if this is a single __watch that contains multiple independent concerns
-        // If so, unwrap it and re-wrap each concern separately
-        if (isAlreadyWrapped(stmt)) {
-            const bodyStmts = getWatchBody(stmt);
-            if (bodyStmts && bodyStmts.length > 1) {
-                // Check if the body has multiple independent reactive groups
-                const groups = groupBodyStatements(bodyStmts, source);
-                if (groups.length > 1) {
-                    // Replace single watch with multiple watches
-                    // Record the original watch range for removal
-                    const watchStart = getLineNumber(source, stmt.start);
-                    const watchEnd = getLineNumber(source, stmt.end);
-                    needsWatch.push({
-                        line: watchStart,
-                        endLine: watchEnd,
-                        replace: true,
-                        groups: groups,
-                    });
-                }
-            }
-            i++;
-            continue;
-        }
-
-        // VariableDeclaration reading pageState — group with subsequent stmts that use declared vars
-        if (stmt.type === 'VariableDeclaration' && containsPageStateRef(stmt)) {
-            const varNames = getDeclaredVarNames(stmt);
-            const groupStmts = [stmt];
-            let j = i + 1;
-
-            // Greedily consume following statements that use any of the declared variable names
-            while (j < ast.body.length) {
-                const next = ast.body[j];
-                if (isAlreadyWrapped(next) || isSetupStatement(next)) break;
-                if (varNames.some(v => usesIdentifier(next, v))) {
-                    groupStmts.push(next);
-                    j++;
-                } else {
-                    break;
-                }
-            }
-
-            needsWatch.push({
-                line: getLineNumber(source, groupStmts[0].start),
-                endLine: getLineNumber(source, groupStmts[groupStmts.length - 1].end),
-            });
-            i = j;
-            continue;
-        }
-
-        // Any other statement referencing pageState
+        if (isAlreadyWrapped(stmt)) continue;
+        if (isSetupOnly(stmt)) continue;
         if (containsPageStateRef(stmt)) {
-            needsWatch.push({
-                line: getLineNumber(source, stmt.start),
-                endLine: getLineNumber(source, stmt.end),
-            });
-            i++;
-            continue;
+            hasUnwrappedPageState = true;
+            if (firstUnwrappedIdx === -1) firstUnwrappedIdx = i;
+            lastUnwrappedIdx = i;
         }
-
-        i++;
     }
 
-    if (needsWatch.length === 0) {
+    if (!hasUnwrappedPageState) {
         return { code: source, wrappedCount: 0, details: [] };
     }
 
-    // Apply wraps bottom-up to preserve line numbers
-    const lines = source.split('\n');
-    const sorted = [...needsWatch].sort((a, b) => b.line - a.line);
-    const details = [];
+    // Find the contiguous range: from first unwrapped pageState ref
+    // to end of file (or last unwrapped ref), including any non-pageState
+    // statements in between (they may depend on reactive variables).
+    // But exclude leading setup-only statements (imports, function decls).
 
-    for (const item of sorted) {
-        const startIdx = item.line - 1;
-        const endIdx = item.endLine - 1;
+    // Walk backwards from firstUnwrappedIdx to include any immediately
+    // preceding non-setup statements that declare variables used later
+    let rangeStart = firstUnwrappedIdx;
+    let rangeEnd = lastUnwrappedIdx;
 
-        if (item.replace && item.groups) {
-            // Replace a single big __watch with multiple smaller ones
-            const indent = lines[startIdx].match(/^(\s*)/)[1];
-            const newLines = [];
-            for (const group of item.groups) {
-                newLines.push(`${indent}pageState.__watch(() => {`);
-                for (const gLine of group.lines) {
-                    newLines.push(`${indent}    ${gLine.trim()}`);
-                }
-                newLines.push(`${indent}});`);
-            }
-            lines.splice(startIdx, endIdx - startIdx + 1, ...newLines);
-            details.push(`L${item.line}-${item.endLine} (split ${item.groups.length})`);
-        } else {
-            const blockLines = lines.slice(startIdx, endIdx + 1);
-            const indent = blockLines[0].match(/^(\s*)/)[1];
-
-            const wrapped = [
-                `${indent}pageState.__watch(() => {`,
-                ...blockLines.map(l => `${indent}    ${l.trim()}`),
-                `${indent}});`,
-            ];
+    // Collect all statements in the range
+    const lines = source.split('\n');
+    const stmtsInRange = ast.body.slice(rangeStart, rangeEnd + 1);
 
-            lines.splice(startIdx, endIdx - startIdx + 1, ...wrapped);
-            details.push(`L${item.line}-${item.endLine}`);
-        }
+    // Check if ALL pageState refs are already wrapped (nothing to do)
+    const unwrappedInRange = stmtsInRange.filter(s => !isAlreadyWrapped(s) && containsPageStateRef(s));
+    if (unwrappedInRange.length === 0) {
+        return { code: source, wrappedCount: 0, details: [] };
     }
 
-    return {
-        code: lines.join('\n'),
-        wrappedCount: needsWatch.length,
-        details
-    };
-}
+    const startLine = getLineNumber(source, stmtsInRange[0].start);
+    const endLine = getLineNumber(source, stmtsInRange[stmtsInRange.length - 1].end);
 
-/**
- * Groups statements inside a __watch body into independent reactive groups.
- * Uses the same logic as the top-level grouping: VariableDeclarations that
- * read pageState get grouped with following statements that use those vars.
- * Standalone if-statements with pageState become their own group.
- */
-function groupBodyStatements(bodyStmts, source) {
-    const groups = [];
-    let i = 0;
+    const startIdx = startLine - 1;
+    const endIdx = endLine - 1;
+    const blockLines = lines.slice(startIdx, endIdx + 1);
+    const indent = blockLines[0].match(/^(\s*)/)[1];
 
-    while (i < bodyStmts.length) {
-        const stmt = bodyStmts[i];
+    const wrapped = [
+        `${indent}pageState.__watch(() => {`,
+        ...blockLines.map(l => `${indent}    ${l.trimEnd()}`),
+        `${indent}});`,
+    ];
 
-        // VariableDeclaration reading pageState — group with dependents
-        if (stmt.type === 'VariableDeclaration' && containsPageStateRef(stmt)) {
-            const varNames = getDeclaredVarNames(stmt);
-            const groupStmts = [stmt];
-            let j = i + 1;
+    lines.splice(startIdx, endIdx - startIdx + 1, ...wrapped);
 
-            while (j < bodyStmts.length) {
-                const next = bodyStmts[j];
-                if (varNames.some(v => usesIdentifier(next, v))) {
-                    groupStmts.push(next);
-                    j++;
-                } else {
-                    break;
-                }
-            }
-
-            groups.push({
-                stmts: groupStmts,
-                lines: extractSourceLines(groupStmts, source),
-            });
-            i = j;
-            continue;
-        }
-
-        // Any statement referencing pageState — standalone group
-        if (containsPageStateRef(stmt)) {
-            groups.push({
-                stmts: [stmt],
-                lines: extractSourceLines([stmt], source),
-            });
-            i++;
-            continue;
-        }
-
-        // Non-reactive statement — attach to next reactive group or skip
-        i++;
-    }
-
-    return groups;
-}
-
-function extractSourceLines(stmts, source) {
-    if (stmts.length === 0) return [];
-    const start = stmts[0].start;
-    const end = stmts[stmts.length - 1].end;
-    return source.slice(start, end).split('\n');
+    return {
+        code: lines.join('\n'),
+        wrappedCount: 1,
+        details: [`L${startLine}-${endLine} (single watch block)`],
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "juxscript",
-  "version": "1.1.281",
+  "version": "1.1.282",
   "type": "module",
   "description": "A JavaScript UX authorship platform",
   "main": "./dist/lib/index.js",