sinwan-compiler 0.1.0 → 0.2.1

package/dist/{chunk-x75bhdr1.js → chunk-tvnem5mj.js}

@@ -17,12 +17,32 @@ var traverse = typeof _traverse === "function" ? _traverse : _traverse.default ?
 var REACTIVE_SOURCE_MODULES = {
   "sinwan/store": new Set(["createMutable", "createStore"]),
   "sinwan/reactivity": new Set(["signal", "computed"]),
+  "sinwan/react": new Set(["useState"]),
   "sinwan/react-client": new Set(["useState"])
 };
 var COMPONENT_FACTORY_MODULES = {
   sinwan: new Set(["cc"]),
   "sinwan/component": new Set(["cc"])
 };
+var BUILTIN_REACTIVE_PROPS = new Map([
+  ["For", { reactiveProps: new Set(["each"]) }],
+  ["Show", { reactiveProps: new Set(["when"]) }],
+  ["Switch", { reactiveProps: new Set(["when"]) }],
+  ["Match", { reactiveProps: new Set(["when"]) }],
+  ["Index", { reactiveProps: new Set(["each"]) }],
+  ["Key", { reactiveProps: new Set(["when"]) }],
+  ["Dynamic", { reactiveProps: new Set(["component"]) }],
+  ["Visible", { reactiveProps: new Set(["when", "style"]) }],
+  ["Portal", { reactiveProps: new Set(["mount"]) }],
+  ["Virtual", { reactiveProps: new Set(["each"]) }],
+  ["Activity", { reactiveProps: new Set(["mode"]) }]
+]);
+function isBuiltinReactiveProp(componentName, attrName) {
+  const entry = BUILTIN_REACTIVE_PROPS.get(componentName);
+  if (!entry)
+    return false;
+  return entry.reactiveProps.has(attrName);
+}
 function trackReactiveImports(ast) {
   const names = {
     createMutable: new Set,
@@ -370,23 +390,31 @@ function containsReactiveRead(expr, scope) {
   visit(expr);
   return found;
 }
-function isComponentExpression(exprPath) {
+function getComponentExpressionInfo(exprPath) {
   const parent = exprPath.parentPath;
-  if (!parent)
-    return false;
+  if (!parent) {
+    return { isComponent: false, componentName: null, attributeName: null };
+  }
   let elementPath = null;
+  let attributeName = null;
   if (parent.isJSXAttribute && parent.isJSXAttribute()) {
+    const attrName = parent.node.name;
+    if (t.isJSXIdentifier(attrName)) {
+      attributeName = attrName.name;
+    }
     const openingElementPath = parent.parentPath;
     elementPath = openingElementPath?.parentPath;
   } else if (parent.isJSXElement && parent.isJSXElement()) {
     elementPath = parent;
   }
   if (!elementPath || !elementPath.isJSXElement || !elementPath.isJSXElement()) {
-    return false;
+    return { isComponent: false, componentName: null, attributeName: null };
   }
   const name = elementPath.node.openingElement.name;
   let firstChar = null;
+  let componentName = null;
   if (t.isJSXIdentifier(name)) {
+    componentName = name.name;
     firstChar = name.name?.[0] ?? null;
   } else if (t.isJSXMemberExpression(name)) {
     let current = name;
@@ -394,12 +422,29 @@ function isComponentExpression(exprPath) {
       current = current.object;
     }
     if (t.isJSXIdentifier(current)) {
+      componentName = current.name;
       firstChar = current.name?.[0] ?? null;
     }
   }
-  if (!firstChar)
+  if (!firstChar || firstChar !== firstChar.toUpperCase() || !/[A-Z]/.test(firstChar)) {
+    return { isComponent: false, componentName: null, attributeName: null };
+  }
+  return { isComponent: true, componentName, attributeName };
+}
+function isReactiveComponentProp(info, componentNames, reactiveProps) {
+  if (!info.isComponent || !info.componentName || !info.attributeName) {
     return false;
-  return firstChar === firstChar.toUpperCase() && /[A-Z]/.test(firstChar);
+  }
+  if (isBuiltinReactiveProp(info.componentName, info.attributeName)) {
+    return true;
+  }
+  const componentFn = componentNames.get(info.componentName);
+  if (!componentFn)
+    return false;
+  const props = reactiveProps.get(componentFn);
+  if (!props)
+    return false;
+  return props.has(info.attributeName);
 }
 function shouldWrap(expr, scope) {
   if (t.isArrowFunctionExpression(expr) || t.isFunctionExpression(expr))
@@ -720,8 +765,12 @@ function wrapReactiveExpressions(ast, options = {}) {
       path2.traverse({
         JSXExpressionContainer(exprPath) {
           const expr = exprPath.node.expression;
-          if (isComponentExpression(exprPath))
-            return;
+          const compInfo = getComponentExpressionInfo(exprPath);
+          if (compInfo.isComponent) {
+            if (!isReactiveComponentProp(compInfo, componentNames, reactiveProps)) {
+              return;
+            }
+          }
           if (shouldWrap(expr, scope)) {
             exprPath.replaceWith(t.jsxExpressionContainer(createBindingDescriptor(expr, exprPath, options)));
           }

package/dist/cli.js

@@ -2,7 +2,7 @@
 // @bun
 import {
   runAnalyzeCli
-} from "./chunk-x75bhdr1.js";
+} from "./chunk-tvnem5mj.js";
 export {
   runAnalyzeCli
 };

package/dist/index.d.ts

@@ -7,4 +7,4 @@
 export { transformJSX, type TransformOptions } from "./transform";
 export { analyze, analyzeProject, analyzeModule, loadMetadata, AnalyzerCache, type AnalyzeOptions, type ModuleAnalysis, type ProjectAnalysis, type ImportedCallSite, type ImportInfo, type WorkspacesConfig, } from "./analyze";
 export { runAnalyzeCli } from "./cli";
-export { wrapReactiveExpressions, trackReactiveImports, collectComponentFunctions, computeLocalScopes, collectComponentCallGraph, propagateReactiveProps, buildFullScope, containsReactiveValue, getAllPropNames, isReactiveValue, type ReactiveScope, type Binding, type CallSite, type ImportNames, } from "./reactive-wrap";
+export { wrapReactiveExpressions, trackReactiveImports, collectComponentFunctions, computeLocalScopes, collectComponentCallGraph, propagateReactiveProps, buildFullScope, containsReactiveValue, getAllPropNames, isReactiveValue, type ReactiveScope, type Binding, type CallSite, type ImportNames, type ComponentExpressionInfo, } from "./reactive-wrap";

package/dist/index.js

@@ -16,7 +16,7 @@ import {
   runAnalyzeCli,
   trackReactiveImports,
   wrapReactiveExpressions
-} from "./chunk-x75bhdr1.js";
+} from "./chunk-tvnem5mj.js";
 
 // src/transform.ts
 import { parse } from "@babel/parser";

package/dist/reactive-wrap.d.ts

@@ -49,6 +49,11 @@ export interface ReactiveScope {
 export declare function getAllPropNames(params: t.Node | undefined): Set<string>;
 export declare function isReactiveValue(node: t.Identifier | t.MemberExpression, scope: ReactiveScope): boolean;
 export declare function containsReactiveValue(expr: t.Expression, scope: ReactiveScope): boolean;
+export interface ComponentExpressionInfo {
+    isComponent: boolean;
+    componentName: string | null;
+    attributeName: string | null;
+}
 export declare function collectComponentFunctions(ast: t.Node, ccNames: Set<string>): {
     functions: Set<t.Function>;
     names: Map<string, t.Function>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sinwan-compiler",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Shared compiler core for Sinwan plugins",
   "type": "module",
   "main": "./dist/index.js",
@@ -30,7 +30,11 @@
     "sinwan": "./dist/cli.js"
   },
   "scripts": {
-    "build": "bun run build.ts"
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "build": "bun run build.ts",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "bun run clean && bun run typecheck && bun run test && bun run build"
   },
   "devDependencies": {
     "@types/babel__generator": "^7.27.0",