sinwan-compiler 0.2.8 → 0.2.10

package/dist/{chunk-v4zrz7j7.js → chunk-qj8m16x2.js}

@@ -300,6 +300,35 @@ function analyzeObjectLiteralSpread(spread, fullScope, calleeReactive) {
 function isMemberLike(node) {
   return t.isMemberExpression(node) || t.isOptionalMemberExpression(node);
 }
+function isFunctionLike(node) {
+  return t.isArrowFunctionExpression(node) || t.isFunctionExpression(node);
+}
+function isCallLike(node) {
+  return t.isCallExpression(node) || t.isOptionalCallExpression(node);
+}
+var COMPILER_BINDING_CALLEES = new Set([
+  "_$bindText",
+  "_$bindAttr",
+  "_$bindStyle",
+  "_$bindClass",
+  "_$unwrap"
+]);
+function isCompilerBindingCall(node) {
+  const callee = node.callee;
+  return t.isIdentifier(callee) && COMPILER_BINDING_CALLEES.has(callee.name);
+}
+function visitCallCalleeAndArgs(node, visitExpr) {
+  if (isCompilerBindingCall(node))
+    return;
+  visitExpr(node.callee, true);
+  for (const arg of node.arguments) {
+    if (t.isSpreadElement(arg)) {
+      visitExpr(arg.argument, true);
+      continue;
+    }
+    visitExpr(arg, true);
+  }
+}
 function getMemberExpressionRootAndPath(node) {
   const path = [];
   let current = node;
@@ -437,11 +466,23 @@ function containsReactiveValue2(expr, scope) {
 }
 function containsReactiveRead(expr, scope) {
   let found = false;
-  function visit(node) {
+  function visit(node, enterFunction) {
     if (found)
       return;
     if (!node || typeof node !== "object")
       return;
+    if (isFunctionLike(node)) {
+      if (!enterFunction)
+        return;
+      for (const param of node.params) {
+        visit(param, false);
+      }
+      visit(node.body, false);
+      return;
+    }
+    if (t.isJSXElement(node) || t.isJSXFragment(node)) {
+      return;
+    }
     if (isMemberLike(node) || t.isTSNonNullExpression(node) || t.isIdentifier(node)) {
       if (isReactiveRead(node, scope)) {
         found = true;
@@ -452,7 +493,8 @@ function containsReactiveRead(expr, scope) {
       found = true;
       return;
     }
-    if (t.isArrowFunctionExpression(node) || t.isFunctionExpression(node)) {
+    if (isCallLike(node)) {
+      visitCallCalleeAndArgs(node, visit);
       return;
     }
     for (const key of Object.keys(node)) {
@@ -462,14 +504,14 @@ function containsReactiveRead(expr, scope) {
       if (Array.isArray(value)) {
         for (const item of value) {
           if (item && typeof item === "object")
-            visit(item);
+            visit(item, false);
         }
       } else if (value && typeof value === "object") {
-        visit(value);
+        visit(value, false);
       }
     }
   }
-  visit(expr);
+  visit(expr, false);
   return found;
 }
 function getComponentExpressionInfo(exprPath) {
@@ -561,11 +603,21 @@ function transformPropMemberAccess(expr, scope) {
       parent.object = resolveRoot(rootName);
     }
   }
-  function visit(node) {
+  function visit(node, enterFunction) {
     if (!node || typeof node !== "object")
       return;
-    if (t.isArrowFunctionExpression(node) || t.isFunctionExpression(node))
+    if (isFunctionLike(node)) {
+      if (!enterFunction)
+        return;
+      for (const param of node.params) {
+        visit(param, false);
+      }
+      visit(node.body, false);
+      return;
+    }
+    if (t.isJSXElement(node) || t.isJSXFragment(node)) {
       return;
+    }
     if (isMemberLike(node)) {
       const rootPath = getMemberExpressionRootAndPath(node);
       if (rootPath) {
@@ -578,6 +630,10 @@ function transformPropMemberAccess(expr, scope) {
       }
       return;
     }
+    if (isCallLike(node)) {
+      visitCallCalleeAndArgs(node, visit);
+      return;
+    }
     for (const key of Object.keys(node)) {
       if (key === "loc" || key === "start" || key === "end" || key === "leadingComments" || key === "trailingComments")
         continue;
@@ -585,14 +641,14 @@ function transformPropMemberAccess(expr, scope) {
       if (Array.isArray(value)) {
         for (const item of value) {
           if (item && typeof item === "object")
-            visit(item);
+            visit(item, false);
         }
       } else if (value && typeof value === "object") {
-        visit(value);
+        visit(value, false);
       }
     }
   }
-  visit(expr);
+  visit(expr, false);
   return changed;
 }
 function wrapExpression(expr) {
@@ -604,6 +660,10 @@ function createBindingDescriptor(expr, exprPath, options) {
   }
   const parent = exprPath.parentPath;
   if (parent && parent.isJSXAttribute && parent.isJSXAttribute()) {
+    const compInfo = getComponentExpressionInfo(exprPath);
+    if (compInfo.isComponent) {
+      return wrapExpression(expr);
+    }
     const attrName = parent.node.name.name;
     if (attrName === "style") {
       return t.callExpression(t.identifier("_$bindStyle"), [

package/dist/cli.js

@@ -3,7 +3,7 @@
 import {
   runAnalyzeCli2,
   runCliIfMain2
-} from "./chunk-v4zrz7j7.js";
+} from "./chunk-qj8m16x2.js";
 export {
   runAnalyzeCli2 as runAnalyzeCli,
   runCliIfMain2 as runCliIfMain

package/dist/index.js

@@ -17,7 +17,7 @@ import {
   propagateReactiveProps2,
   wrapReactiveExpressions2,
   runAnalyzeCli2
-} from "./chunk-v4zrz7j7.js";
+} from "./chunk-qj8m16x2.js";
 
 // src/transform.ts
 import { parse } from "@babel/parser";

package/docs/README.md

@@ -19,6 +19,7 @@ autoWrapComponents()     plain `export function App()` → cc(App)
     │
     ▼
 wrapReactiveExpressions()   {count.value} → {() => count.value}
+                            {arr.map(x => n.value)} → {() => arr.map(...)}
                             also wraps those reads as children/attrs of <Label>
     │
     ▼

package/docs/plugins.md

@@ -51,6 +51,7 @@ The Vite plugin sets `resolve.dedupe: ["sinwan"]` for the same duplicate-runtime
 | Option | Default | Role |
 | ------ | ------- | ---- |
 | `hoist` | `true` | Template hoisting |
+| `dev` | Bun: `NODE_ENV !== "production"` at `sinwan()`; Vite: `config.mode !== "production"` | Warn when hoisting is skipped. Pass `false` for library/`Bun.build` production bundles. |
 | `explicitBindings` | `false` | `_$bind*` helpers instead of bare `() =>` |
 | `analyze` | unset | Path to CLI JSON (production) |
 | `cache` | `true` | Incremental analyzer in dev. `false` turns it off. An object sets `root`, `tsConfigPath`, `bunfigPath`, `workspaces`, `cachePath` |

package/docs/transform.md

@@ -72,12 +72,14 @@ Reads the compiler wraps:
 - `useState` getters: `count()`
 - `useFetch` signal values: `f.data.value` (not the shell `f` or `f.data`)
 - Calls to a **local** function whose body reads one of the above
+- Reads **inside call callbacks** that run while the JSX expression is evaluated: `.map` / `.filter` / `Array.from` callbacks, IIFEs, and default parameters of those callbacks. `<For each={keys.map((k) => groups[query.value])}>` becomes `each={() => keys.map(...)}`. Nested JSX inside those callbacks is a separate wrap site (`items.map((i) => <span>{count.value}</span>)` wraps the inner text, not the whole map).
 
 Not wrapped:
 
 - Literals and plain identifiers
 - Event-handler functions (`onClick={fn}` or `onClick={() => …}`)
 - Nested function *values* passed as props (`title={() => s.value}` stays a render prop)
+- Functions stored as object/array values (`{ onClick: () => s.value }`) or returned from a factory (`const make = () => () => s.value`)
 - `useFetch` methods such as `abort` / `execute`
 - Static values the [analyzer](analyzer.md) proved never change
 
@@ -88,7 +90,7 @@ Not wrapped:
 **User components** (`<Label>`, `<Child title={…} />`):
 
 - **Children:** wrap reactive reads the same way as DOM text (`{count.value}`, `{checked.value ? "On" : "Off"}`) so `cc()` parents do not snapshot the value. Use a getter (`() => …`), never `_$bindText`, because the child may render nodes as well as strings. Render-prop functions (`{(v) => …}`) stay untouched.
-- **Props:** wrap a prop if it is known-reactive for that component (built-in registry, local call graph, analyzer metadata). For *unknown* imported components, still wrap **derived reads** (`htmlFor={id.value}`, `disabled={off.value}`) and leave **container pass-through** alone (`checked={checked}`, `user={user}`) so the child receives the signal or store proxy.
+- **Props:** wrap a prop if it is known-reactive for that component (built-in registry, local call graph, analyzer metadata). For *unknown* imported components, still wrap **derived reads** (`htmlFor={id.value}`, `disabled={off.value}`) and leave **container pass-through** alone (`checked={checked}`, `user={user}`) so the child receives the signal or store proxy. With `explicitBindings`, component props stay **getters** (`each={() => …}`), never `_$bindAttr` — `For` / `Show` / `Label` call `resolve(prop)`, which does not unwrap bind descriptors.
 
 **Built-in control-flow** components wrap specific props, and they wrap reactive expression children (those children render directly):
 
@@ -139,6 +141,6 @@ transformJSX(code, "src/App.tsx", {
 
 - **`analyze` / `analyzeMetadata`** — cross-file reactive props. Invalid JSON is ignored (transform still succeeds).
 - **`resolveImport`** — maps `./Child` to an absolute file so imported components can use analyzer metadata. Without it, imported call sites are not wrapped at the parent.
-- **`explicitBindings`** — wrap with `_$bindText` / `_$bindAttr` / `_$bindStyle` / `_$bindClass` from `sinwan/renderer` instead of a bare `() => …`.
+- **`explicitBindings`** — wrap **native** text/attrs with `_$bindText` / `_$bindAttr` / `_$bindStyle` / `_$bindClass`. Component props and component children stay `() => …` so `resolve(prop)` still sees a getter.
 
 Returns `{ code, map }` with a source map.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sinwan-compiler",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "Shared compiler core for Sinwan plugins",
   "type": "module",
   "main": "./dist/index.js",