@sigil-dev/compiler 0.7.5 → 0.7.6

package/src/babel/jsx/utils.ts

@@ -1,51 +1,57 @@
 import { types as t } from "@babel/core";
 
 export const ATTR_MAP: Record<string, string> = {
-	class: "className",
-	for: "htmlFor",
+    class: "className",
+    for: "htmlFor",
 };
 
 export function containsSignal(
-	expr: t.Expression,
-	signals: Set<string>,
+    expr: t.Expression,
+    signals: Set<string>,
 ): boolean {
-	if (t.isIdentifier(expr)) return signals.has(expr.name);
-	if (t.isCallExpression(expr)) {
-		return containsSignal(expr.callee as t.Expression, signals);
-	}
-	if (t.isBinaryExpression(expr)) {
-		return (
-			containsSignal(expr.left as t.Expression, signals) ||
-			containsSignal(expr.right, signals)
-		);
-	}
-	if (t.isMemberExpression(expr)) {
-		return containsSignal(expr.object as t.Expression, signals);
-	}
-	if (t.isLogicalExpression(expr)) {
-		return (
-			containsSignal(expr.left as t.Expression, signals) ||
-			containsSignal(expr.right as t.Expression, signals)
-		);
-	}
-	if (t.isConditionalExpression(expr)) {
-		return (
-			containsSignal(expr.test as t.Expression, signals) ||
-			containsSignal(expr.consequent as t.Expression, signals) ||
-			containsSignal(expr.alternate as t.Expression, signals)
-		);
-	}
-	return false;
+    if (t.isIdentifier(expr)) return signals.has(expr.name);
+    if (t.isCallExpression(expr)) {
+        return containsSignal(expr.callee as t.Expression, signals);
+    }
+    if (t.isBinaryExpression(expr)) {
+        return (
+            containsSignal(expr.left as t.Expression, signals) ||
+            containsSignal(expr.right, signals)
+        );
+    }
+    if (t.isMemberExpression(expr)) {
+        return containsSignal(expr.object as t.Expression, signals);
+    }
+    if (t.isLogicalExpression(expr)) {
+        return (
+            containsSignal(expr.left as t.Expression, signals) ||
+            containsSignal(expr.right as t.Expression, signals)
+        );
+    }
+    if (t.isConditionalExpression(expr)) {
+        return (
+            containsSignal(expr.test as t.Expression, signals) ||
+            containsSignal(expr.consequent as t.Expression, signals) ||
+            containsSignal(expr.alternate as t.Expression, signals)
+        );
+    }
+    if (t.isUnaryExpression(expr)) {
+        return containsSignal(expr.argument as t.Expression, signals);
+    }
+    if (t.isTemplateLiteral(expr)) {
+        return expr.expressions.some(e => containsSignal(e as t.Expression, signals));
+    }
+    return false;
 }
 
 export function isPrimitive(expr: t.Expression): boolean {
-	if (t.isCallExpression(expr) && t.isIdentifier(expr.callee)) return true;
-	if (t.isBinaryExpression(expr)) return true;
-	if (t.isTemplateLiteral(expr)) return true;
-	if (t.isIdentifier(expr)) return true;
-	// user().name is a MemberExpression after state handler rewrites user → user()
-	if (t.isMemberExpression(expr)) return true;
-	return false;
+    if (t.isCallExpression(expr) && t.isIdentifier(expr.callee)) return true;
+    if (t.isBinaryExpression(expr)) return true;
+    if (t.isTemplateLiteral(expr)) return true;
+    if (t.isIdentifier(expr)) return true;
+    // user().name is a MemberExpression after state handler rewrites user → user()
+    if (t.isMemberExpression(expr)) return true;
+    return false;
 }
 
 /**
@@ -53,22 +59,22 @@ export function isPrimitive(expr: t.Expression): boolean {
  * When parentVar is provided, passes it to claim() for SPA fallback (append on create).
  */
 export function getCreateElement(
-	tag: string,
-	hydrate: boolean,
-	nodesVar = "__nodes",
-	parentVar?: string,
+    tag: string,
+    hydrate: boolean,
+    nodesVar = "__nodes",
+    parentVar?: string,
 ): t.Expression {
-	if (hydrate) {
-		const args: t.Expression[] = [t.identifier(nodesVar), t.stringLiteral(tag)];
-		if (parentVar) {
-			args.push(t.identifier(parentVar));
-		}
-		return t.callExpression(t.identifier("claim"), args);
-	}
-	return t.callExpression(
-		t.memberExpression(t.identifier("document"), t.identifier("createElement")),
-		[t.stringLiteral(tag)],
-	);
+    if (hydrate) {
+        const args: t.Expression[] = [t.identifier(nodesVar), t.stringLiteral(tag)];
+        if (parentVar) {
+            args.push(t.identifier(parentVar));
+        }
+        return t.callExpression(t.identifier("claim"), args);
+    }
+    return t.callExpression(
+        t.memberExpression(t.identifier("document"), t.identifier("createElement")),
+        [t.stringLiteral(tag)],
+    );
 }
 
 /**
@@ -76,24 +82,24 @@ export function getCreateElement(
  * When parentVar is provided, passes it to claimText() for SPA fallback.
  */
 export function getCreateText(
-	hydrate: boolean,
-	nodesVar = "__nodes",
-	parentVar?: string,
+    hydrate: boolean,
+    nodesVar = "__nodes",
+    parentVar?: string,
 ): t.Expression {
-	if (hydrate) {
-		const args: t.Expression[] = [t.identifier(nodesVar)];
-		if (parentVar) {
-			args.push(t.identifier(parentVar));
-		}
-		return t.callExpression(t.identifier("claimText"), args);
-	}
-	return t.callExpression(
-		t.memberExpression(
-			t.identifier("document"),
-			t.identifier("createTextNode"),
-		),
-		[t.stringLiteral("")],
-	);
+    if (hydrate) {
+        const args: t.Expression[] = [t.identifier(nodesVar)];
+        if (parentVar) {
+            args.push(t.identifier(parentVar));
+        }
+        return t.callExpression(t.identifier("claimText"), args);
+    }
+    return t.callExpression(
+        t.memberExpression(
+            t.identifier("document"),
+            t.identifier("createTextNode"),
+        ),
+        [t.stringLiteral("")],
+    );
 }
 
 /**
@@ -101,24 +107,24 @@ export function getCreateText(
  * Returns the generated variable name for use by children.
  */
 export function buildHydrationScope(
-	parentVar: string,
-	statements: t.Statement[],
-	nodesVar: string,
+    parentVar: string,
+    statements: t.Statement[],
+    nodesVar: string,
 ): void {
-	statements.push(
-		t.variableDeclaration("const", [
-			t.variableDeclarator(
-				t.identifier(nodesVar),
-				t.callExpression(
-					t.memberExpression(t.identifier("Array"), t.identifier("from")),
-					[
-						t.memberExpression(
-							t.identifier(parentVar),
-							t.identifier("childNodes"),
-						),
-					],
-				),
-			),
-		]),
-	);
+    statements.push(
+        t.variableDeclaration("const", [
+            t.variableDeclarator(
+                t.identifier(nodesVar),
+                t.callExpression(
+                    t.memberExpression(t.identifier("Array"), t.identifier("from")),
+                    [
+                        t.memberExpression(
+                            t.identifier(parentVar),
+                            t.identifier("childNodes"),
+                        ),
+                    ],
+                ),
+            ),
+        ]),
+    );
 }

package/src/babel/util/bind.ts

@@ -1,135 +1,126 @@
-import { types as t } from "@babel/core";
-
-const BIND_EVENT: Record<string, string> = {
-	value: "input",
-	checked: "change",
-};
-
-export function buildBind(
-  varName: string,
-  attrName: string,
-  attr: t.JSXAttribute,
-  statements: t.Statement[],
-): void {
-  const signal = (attr.value as t.JSXExpressionContainer)
-    .expression as t.CallExpression; // already text()
-
-  const signalId = signal.callee as t.Identifier; // text — for .set()
-
-  if (attrName === "bindThis") {
-    statements.push(
-      t.expressionStatement(
-        t.callExpression(
-          t.memberExpression(signalId, t.identifier("set")),
-          [t.identifier(varName)],
-        ),
-      ),
-    );
-    return;
-  }
-
-  const prop = attrName.slice(4).toLowerCase();
-  const event = BIND_EVENT[prop] ?? "input";
-
-  // createEffect(() => _el.prop = text())
-  statements.push(
-    t.expressionStatement(
-      t.callExpression(t.identifier("createEffect"), [
-        t.arrowFunctionExpression(
-          [],
-          t.blockStatement([
-            t.expressionStatement(
-              t.assignmentExpression(
-                "=",
-                t.memberExpression(t.identifier(varName), t.identifier(prop)),
-                signal, // text() — already correct
-              ),
-            ),
-          ]),
-        ),
-      ]),
-    ),
-  );
-
-  // addEventListener(event, e => text.set(e.target.prop))
-  statements.push(
-    t.expressionStatement(
-      t.callExpression(
-        t.memberExpression(t.identifier(varName), t.identifier("addEventListener")),
-        [
-          t.stringLiteral(event),
-          t.arrowFunctionExpression(
-            [t.identifier("e")],
-            t.callExpression(
-              t.memberExpression(signalId, t.identifier("set")),
-              [
-                t.memberExpression(
-                  t.memberExpression(t.identifier("e"), t.identifier("target")),
-                  t.identifier(prop),
-                ),
-              ],
-            ),
-          ),
-        ],
-      ),
-    ),
-  );
-}
-
-export function buildProxyBind(
-  varName: string,
-  attrName: string,
-  attr: t.JSXAttribute,
-  statements: t.Statement[],
-  signal: t.MemberExpression, // already form().name
-): void {
-  const prop = attrName.slice(4).toLowerCase();
-  const event = BIND_EVENT[prop] ?? "input";
-
-  // createEffect(() => el.prop = form().name)
-  statements.push(
-    t.expressionStatement(
-      t.callExpression(t.identifier("createEffect"), [
-        t.arrowFunctionExpression(
-          [],
-          t.blockStatement([
-            t.expressionStatement(
-              t.assignmentExpression(
-                "=",
-                t.memberExpression(t.identifier(varName), t.identifier(prop)),
-                signal,
-              ),
-            ),
-          ]),
-        ),
-      ]),
-    ),
-  );
-
-  // addEventListener(event, e => { form().name = e.target.prop })
-  statements.push(
-    t.expressionStatement(
-      t.callExpression(
-        t.memberExpression(t.identifier(varName), t.identifier("addEventListener")),
-        [
-          t.stringLiteral(event),
-          t.arrowFunctionExpression(
-            [t.identifier("e")],
-            t.blockStatement([
-              t.expressionStatement(
-                t.assignmentExpression(
-                  "=",
-                  signal as unknown as t.LVal, // form().name — valid LVal
-                  t.memberExpression(
-                    t.memberExpression(t.identifier("e"), t.identifier("target")),
-                    t.identifier(prop),
-                  ),
-                ),
-              ),
-            ]),
-          ),
-        ],
-      ),
-    ),
-  );
-}
+import { types as t } from "@babel/core";
+
+const BIND_EVENT: Record<string, string> = {
+	value: "input",
+	checked: "change",
+	innerHTML: "input",
+	textContent: "input",
+	group: "change",
+};
+
+export function buildBind(
+  varName: string,
+  bindProp: string,
+  attr: t.JSXAttribute,
+  statements: t.Statement[],
+): void {
+  const signal = (attr.value as t.JSXExpressionContainer)
+    .expression as t.CallExpression; // already text()
+
+  const signalId = signal.callee as t.Identifier; // text — for .set()
+
+  const event = BIND_EVENT[bindProp] ?? "input";
+
+  // createEffect(() => _el.prop = text())
+  statements.push(
+    t.expressionStatement(
+      t.callExpression(t.identifier("createEffect"), [
+        t.arrowFunctionExpression(
+          [],
+          t.blockStatement([
+            t.expressionStatement(
+              t.assignmentExpression(
+                "=",
+                t.memberExpression(t.identifier(varName), t.identifier(bindProp)),
+                signal,
+              ),
+            ),
+          ]),
+        ),
+      ]),
+    ),
+  );
+
+  // addEventListener(event, e => text.set(e.target.prop))
+  statements.push(
+    t.expressionStatement(
+      t.callExpression(
+        t.memberExpression(t.identifier(varName), t.identifier("addEventListener")),
+        [
+          t.stringLiteral(event),
+          t.arrowFunctionExpression(
+            [t.identifier("e")],
+            t.callExpression(
+              t.memberExpression(signalId, t.identifier("set")),
+              [
+                t.memberExpression(
+                  t.memberExpression(t.identifier("e"), t.identifier("target")),
+                  t.identifier(bindProp),
+                ),
+              ],
+            ),
+          ),
+        ],
+      ),
+    ),
+  );
+}
+
+export function buildProxyBind(
+  varName: string,
+  bindProp: string,
+  attr: t.JSXAttribute,
+  statements: t.Statement[],
+  signal: t.MemberExpression, // already form().name
+): void {
+  const event = BIND_EVENT[bindProp] ?? "input";
+
+  // createEffect(() => el.prop = form().name)
+  statements.push(
+    t.expressionStatement(
+      t.callExpression(t.identifier("createEffect"), [
+        t.arrowFunctionExpression(
+          [],
+          t.blockStatement([
+            t.expressionStatement(
+              t.assignmentExpression(
+                "=",
+                t.memberExpression(t.identifier(varName), t.identifier(bindProp)),
+                signal,
+              ),
+            ),
+          ]),
+        ),
+      ]),
+    ),
+  );
+
+  // addEventListener(event, e => { form().name = e.target.prop })
+  statements.push(
+    t.expressionStatement(
+      t.callExpression(
+        t.memberExpression(t.identifier(varName), t.identifier("addEventListener")),
+        [
+          t.stringLiteral(event),
+          t.arrowFunctionExpression(
+            [t.identifier("e")],
+            t.blockStatement([
+              t.expressionStatement(
+                t.assignmentExpression(
+                  "=",
+                  signal as unknown as t.LVal, // form().name — valid LVal
+                  t.memberExpression(
+                    t.memberExpression(t.identifier("e"), t.identifier("target")),
+                    t.identifier(bindProp),
+                  ),
+                ),
+              ),
+            ]),
+          ),
+        ],
+      ),
+    ),
+  );
+}
+
+