@llui/vite-plugin 0.0.20 → 0.0.22

package/dist/transform.js

@@ -105,7 +105,7 @@ const PROP_KEYS = new Set([
  * string. With resolution, we see that `cls` is an arrow and emit a
  * binding exactly as if the arrow had been inlined.
  *
- * Scope rules:
+ * Lifetime rules:
  *   - Only single-binding `const`/`let`/`var` declarations with an
  *     initializer are considered. No destructuring, no multi-declarator
  *     statements (too easy to get wrong without a type checker).
@@ -172,7 +172,7 @@ function resolveKey(key, kind) {
         return 'class';
     return key;
 }
-export function transformLlui(source, _filename, devMode = false, mcpPort = 5200) {
+export function transformLlui(source, _filename, devMode = false, mcpPort = 5200, verbose = false) {
     const sourceFile = ts.createSourceFile('input.ts', source, ts.ScriptTarget.Latest, true);
     // Find the @llui/dom import
     const imp = findLluiImport(sourceFile);
@@ -189,6 +189,13 @@ export function transformLlui(source, _filename, devMode = false, mcpPort = 5200
     // won't match. Files without component() get FULL_MASK on all bindings.
     const fileHasComponent = hasComponentDef(sourceFile, lluiImport);
     const fieldBits = fileHasComponent ? collectDeps(source) : new Map();
+    if (verbose && fileHasComponent) {
+        const pairs = [...fieldBits.entries()]
+            .map(([path, bit]) => `${path}=${bit === -1 ? 'FULL' : bit}`)
+            .join(', ');
+        console.info(`[llui] ${_filename}: ${fieldBits.size} reactive path${fieldBits.size === 1 ? '' : 's'}` +
+            (pairs.length > 0 ? ` — ${pairs}` : ''));
+    }
     // Identifier names bound to the View<S,M> helpers parameter of a `view` callback.
     // When the user writes `h.text(...)` / `h.show(...)` / `h.each(...)`, the
     // compiler treats the call as if it were a bare import call.
@@ -551,9 +558,11 @@ function isViewTypeReference(t) {
 const VIEW_HELPER_PRIMITIVES = new Set([
     'show',
     'branch',
+    'scope',
     'each',
     'text',
     'memo',
+    'sample',
     'selector',
     'ctx',
     'slice',
@@ -877,11 +886,12 @@ function tryInjectTextMask(node, lluiImport, viewHelperNames, viewHelperAliases,
 function tryInjectStructuralMask(node, viewHelperNames, viewHelperAliases, fieldBits, f) {
     if (fieldBits.size === 0)
         return null;
-    // Match each(), branch(), show() — bare, aliased, or member-call
+    // Match each(), branch(), scope(), show() — bare, aliased, or member-call
     const isEach = isHelperCall(node.expression, 'each', viewHelperNames, viewHelperAliases);
     const isBranch = isHelperCall(node.expression, 'branch', viewHelperNames, viewHelperAliases);
+    const isScope = isHelperCall(node.expression, 'scope', viewHelperNames, viewHelperAliases);
     const isShow = isHelperCall(node.expression, 'show', viewHelperNames, viewHelperAliases);
-    if (!isEach && !isBranch && !isShow)
+    if (!isEach && !isBranch && !isScope && !isShow)
         return null;
     const optsArg = node.arguments[0];
     if (!optsArg || !ts.isObjectLiteralExpression(optsArg))
@@ -894,8 +904,9 @@ function tryInjectStructuralMask(node, viewHelperNames, viewHelperAliases, field
             return null;
         }
     }
-    // Find the driving accessor property: items/on/when
-    const driverProp = isEach ? 'items' : isBranch ? 'on' : 'when';
+    // Find the driving accessor property: items / on / when
+    //   each → 'items', branch/scope → 'on', show → 'when'
+    const driverProp = isEach ? 'items' : isBranch || isScope ? 'on' : 'when';
     let driverAccessor = null;
     for (const prop of optsArg.properties) {
         if (ts.isPropertyAssignment(prop) &&
@@ -1749,7 +1760,7 @@ function _containsSelectorBind(node) {
 }
 function containsStructuralCall(node) {
     if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
-        if (['each', 'branch', 'show', 'child', 'foreign'].includes(node.expression.text))
+        if (['each', 'branch', 'scope', 'show', 'child', 'foreign'].includes(node.expression.text))
             return true;
     }
     return ts.forEachChild(node, containsStructuralCall) ?? false;
@@ -1784,7 +1795,7 @@ function computeStructuralMask(configArg, fieldBits) {
     function walk(node) {
         if (ts.isCallExpression(node)) {
             const name = ts.isIdentifier(node.expression) ? node.expression.text : '';
-            if (['each', 'branch', 'show'].includes(name) && node.arguments[0]) {
+            if (['each', 'branch', 'scope', 'show'].includes(name) && node.arguments[0]) {
                 foundStructural = true;
                 const opts = node.arguments[0];
                 if (ts.isObjectLiteralExpression(opts)) {
@@ -2978,7 +2989,7 @@ function isPerItemCall(node) {
     return ts.isArrowFunction(arg) || ts.isFunctionExpression(arg);
 }
 // Matches: item.FIELD — the item-proxy shorthand equivalent of item(t => t.FIELD).
-// Scope-checked: the `item` identifier must resolve to a parameter of an
+// Lifetime-checked: the `item` identifier must resolve to a parameter of an
 // `each({ render })` callback. Without this check, plain
 // `arr.map((item) => item.field)` outside each() would be rewritten as a
 // per-item binding and crash at runtime with "accessor is not a function"