babel-plugin-essor 0.0.15-beta.1 → 0.0.15-beta.5

package/dist/index.cjs

@@ -42,7 +42,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/program.ts
-var import_core2 = require("@babel/core");
+var import_core4 = require("@babel/core");
 
 // src/import.ts
 var import_core = require("@babel/core");
@@ -228,75 +228,31 @@ function createImport(path, imports, from) {
   }
 }
 
-// src/program.ts
-var transformProgram = {
-  enter: (path, state) => {
-    const opts = __spreadValues(__spreadValues({}, DEFAULT_OPTIONS), state.opts);
-    const imports = createImportIdentifiers(path);
-    clearImport();
-    path.state = __spreadProps(__spreadValues({}, state), {
-      opts,
-      imports,
-      declarations: [],
-      // Collect template declarations during transformation
-      filename: state.filename,
-      events: /* @__PURE__ */ new Set()
-      // Track delegated events for optimization
-    });
-  },
-  // eslint-disable-next-line unused-imports/no-unused-vars
-  exit: (path, state) => {
-    const pluginState = path.state;
-    const { imports, declarations, events } = pluginState;
-    const insertIndex = path.node.body.findIndex(
-      (node) => !import_core2.types.isImportDeclaration(node) && !import_core2.types.isExportDeclaration(node)
-    );
-    if (declarations == null ? void 0 : declarations.length) {
-      const templateDeclaration = import_core2.types.variableDeclaration("const", declarations);
-      if (insertIndex !== -1) {
-        path.node.body.splice(insertIndex, 0, templateDeclaration);
-      } else {
-        path.node.body.push(templateDeclaration);
-      }
-    }
-    if (events && events.size > 0) {
-      const eventsDeclaration = import_core2.types.expressionStatement(
-        import_core2.types.callExpression(imports.delegateEvents, [
-          import_core2.types.arrayExpression(Array.from(events).map((event) => import_core2.types.stringLiteral(event)))
-        ])
-      );
-      addImport(importMap.delegateEvents);
-      path.node.body.push(eventsDeclaration);
-    }
-    createImport(path, imports, "essor");
-  }
-};
-
-// src/signals/props.ts
-var import_core4 = require("@babel/core");
+// src/signals/symbol.ts
+var import_core3 = require("@babel/core");
 
 // src/signals/utils.ts
-var import_core3 = require("@babel/core");
+var import_core2 = require("@babel/core");
 function isValidPath(path) {
   return !!(path && path.node);
 }
 function isJSXNode(node) {
-  return !!(node && (import_core3.types.isJSXElement(node) || import_core3.types.isJSXFragment(node)));
+  return !!(node && (import_core2.types.isJSXElement(node) || import_core2.types.isJSXFragment(node)));
 }
 function mightReturnJSX(expr) {
   if (isJSXNode(expr)) {
     return true;
   }
-  if (import_core3.types.isConditionalExpression(expr)) {
+  if (import_core2.types.isConditionalExpression(expr)) {
     return mightReturnJSX(expr.consequent) || mightReturnJSX(expr.alternate);
   }
-  if (import_core3.types.isLogicalExpression(expr)) {
+  if (import_core2.types.isLogicalExpression(expr)) {
     return mightReturnJSX(expr.left) || mightReturnJSX(expr.right);
   }
-  if (import_core3.types.isSequenceExpression(expr)) {
+  if (import_core2.types.isSequenceExpression(expr)) {
     return expr.expressions.some(mightReturnJSX);
   }
-  if (import_core3.types.isParenthesizedExpression(expr)) {
+  if (import_core2.types.isParenthesizedExpression(expr)) {
     return mightReturnJSX(expr.expression);
   }
   return false;
@@ -306,7 +262,7 @@ function checkHasJSXReturn(path) {
   try {
     const body = path.get("body");
     if (!isValidPath(body)) return false;
-    if (!import_core3.types.isBlockStatement(body.node)) {
+    if (!import_core2.types.isBlockStatement(body.node)) {
       return mightReturnJSX(body.node);
     }
     let hasJSX = false;
@@ -327,202 +283,22 @@ function checkHasJSXReturn(path) {
   }
 }
 function isMemberAccessingProperty(node, propertyName) {
-  if (!node.computed && import_core3.types.isIdentifier(node.property) && node.property.name === propertyName) {
+  if (!node.computed && import_core2.types.isIdentifier(node.property) && node.property.name === propertyName) {
     return true;
   }
-  if (node.computed && import_core3.types.isStringLiteral(node.property) && node.property.value === propertyName) {
+  if (node.computed && import_core2.types.isStringLiteral(node.property) && node.property.value === propertyName) {
     return true;
   }
   return false;
 }
 
-// src/signals/props.ts
-function transformProperty(path, properties, parentPath, defaultValues = {}) {
-  properties.forEach((property, index) => {
-    try {
-      if (!import_core4.types.isObjectProperty(property)) {
-        return;
-      }
-      if (!import_core4.types.isIdentifier(property.key)) {
-        if (true) {
-          ne("transformObjectProperties: Skipping computed property", { index });
-        }
-        return;
-      }
-      const keyName = property.key.name;
-      if (import_core4.types.isIdentifier(property.value)) {
-        path.scope.rename(property.value.name, `${parentPath}.${keyName}`);
-      } else if (import_core4.types.isAssignmentPattern(property.value)) {
-        if (import_core4.types.isIdentifier(property.value.left)) {
-          defaultValues[keyName] = property.value.right;
-          path.scope.rename(property.value.left.name, `${parentPath}.${keyName}`);
-        } else if (import_core4.types.isObjectPattern(property.value.left)) {
-          transformProperty(
-            path,
-            property.value.left.properties,
-            `${parentPath}.${keyName}`,
-            defaultValues
-          );
-          defaultValues[keyName] = property.value.right;
-        }
-      } else if (import_core4.types.isObjectPattern(property.value)) {
-        transformProperty(
-          path,
-          property.value.properties,
-          `${parentPath}.${keyName}`,
-          defaultValues
-        );
-      }
-    } catch (error) {
-      ne("transformProperty", `Failed to process property at index ${index}`, {
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  });
-  return defaultValues;
-}
-function buildRestVariableDeclaration(state, restName, parentPath, excludeProps) {
-  const validExcludeProps = excludeProps.filter(Boolean);
-  let init;
-  const pathParts = parentPath.split(".").filter((part) => part.length > 0);
-  let sourceObject = import_core4.types.identifier(pathParts[0] || "__props");
-  for (let i = 1; i < pathParts.length; i++) {
-    sourceObject = import_core4.types.memberExpression(sourceObject, import_core4.types.identifier(pathParts[i]));
-  }
-  if (validExcludeProps.length === 0) {
-    init = sourceObject;
-  } else {
-    init = import_core4.types.callExpression(state.imports.omitProps, [
-      sourceObject,
-      import_core4.types.arrayExpression(validExcludeProps.map((name) => import_core4.types.stringLiteral(name)))
-    ]);
-  }
-  return import_core4.types.variableDeclaration("const", [import_core4.types.variableDeclarator(import_core4.types.identifier(restName), init)]);
-}
-function transformRestProperties(path, restProperties, notRestNames = [], nestedRestParams = []) {
-  if (!import_core4.types.isIdentifier(restProperties.argument)) {
-    return;
-  }
-  const restName = restProperties.argument.name;
-  if (notRestNames.length === 0 && nestedRestParams.length === 0) {
-    path.node.params[0] = import_core4.types.identifier(restName);
-  } else {
-    const restDeclarations = [];
-    if (nestedRestParams.length > 0) {
-      for (const nestedRest of nestedRestParams) {
-        const nestedRestDeclaration = buildRestVariableDeclaration(
-          path.state,
-          nestedRest.name,
-          nestedRest.parentPath,
-          nestedRest.excludeProps
-        );
-        restDeclarations.push(nestedRestDeclaration);
-        if (nestedRest.excludeProps.length > 0) {
-          addImport(importMap.omitProps);
-        }
-      }
-    }
-    if (restProperties) {
-      const restDeclaration = buildRestVariableDeclaration(
-        path.state,
-        restName,
-        TRANSFORM_PROPERTY_NAME,
-        notRestNames
-      );
-      restDeclarations.push(restDeclaration);
-      if (notRestNames.length) {
-        addImport(importMap.omitProps);
-      }
-    }
-    for (const declaration of restDeclarations) {
-      const body = path.node.body;
-      body.body.unshift(declaration);
-    }
-  }
-}
-function buildDefaultValueObject(defaultValues) {
-  if (!P(defaultValues)) {
-    return import_core4.types.objectExpression([]);
-  }
-  const properties = [];
-  for (const [key, value] of Object.entries(defaultValues)) {
-    if (!key) {
-      continue;
-    }
-    let propertyValue;
-    if (P(value) && !import_core4.types.isNode(value)) {
-      propertyValue = buildDefaultValueObject(value);
-    } else if (import_core4.types.isExpression(value)) {
-      propertyValue = value;
-    } else {
-      continue;
-    }
-    properties.push(import_core4.types.objectProperty(import_core4.types.identifier(key), propertyValue));
-  }
-  return import_core4.types.objectExpression(properties);
-}
-function buildDefaultValue(path, defaultValues) {
-  const propsParam = Object.keys(defaultValues).length > 0 ? import_core4.types.assignmentPattern(
-    import_core4.types.identifier(TRANSFORM_PROPERTY_NAME),
-    buildDefaultValueObject(defaultValues)
-  ) : import_core4.types.identifier(TRANSFORM_PROPERTY_NAME);
-  path.node.params[0] = propsParam;
-}
-function transformProps(path) {
-  const firstParam = path.node.params[0];
-  if (!firstParam || !import_core4.types.isObjectPattern(firstParam) || !checkHasJSXReturn(path)) {
-    return;
-  }
-  const state = path.state;
-  const properties = firstParam.properties;
-  const signalPrefix = state.opts.symbol || "$";
-  const notRestProperties = properties.filter((prop) => !import_core4.types.isRestElement(prop));
-  const restProperties = properties.find((prop) => import_core4.types.isRestElement(prop));
-  const notRestNames = notRestProperties.map((prop) => import_core4.types.isIdentifier(prop.key) ? prop.key.name : null).filter((name) => name !== null);
-  if (true) {
-    if (notRestNames.some((name) => q(name, signalPrefix))) {
-      ne(
-        "transformProps",
-        "Property names cannot start with signal prefix",
-        notRestNames.filter((name) => q(name, signalPrefix))
-      );
-    }
-  }
-  if (notRestProperties.length) {
-    const defaultValues = transformProperty(path, notRestProperties, TRANSFORM_PROPERTY_NAME);
-    buildDefaultValue(path, defaultValues);
-  }
-  if (restProperties) {
-    transformRestProperties(path, restProperties, notRestNames);
-  }
-}
-
-// src/jsx/context.ts
-var contextStack = [];
-function getContext() {
-  if (!contextStack.length) {
-    throw new Error("No active context found. Ensure setContext has been called.");
-  }
-  return contextStack[contextStack.length - 1];
-}
-function setContext(context) {
-  contextStack.push(context);
-}
-function resetContext() {
-  contextStack.pop();
-}
-
-// src/jsx/client.ts
-var import_core8 = require("@babel/core");
-
 // src/signals/symbol.ts
-var import_core5 = require("@babel/core");
 function isSignal(name) {
   return !!name && name.startsWith("$");
 }
 function replaceSymbol(path) {
   const { init, id } = path.node;
-  if (!import_core5.types.isIdentifier(id)) {
+  if (!import_core3.types.isIdentifier(id)) {
     return;
   }
   const variableName = id.name;
@@ -532,16 +308,16 @@ function replaceSymbol(path) {
   if (isAlreadySignalCall(init)) {
     return;
   }
-  const isComputed = init && (import_core5.types.isFunctionExpression(init) || import_core5.types.isArrowFunctionExpression(init)) && path.parent.kind === "const";
+  const isComputed = init && (import_core3.types.isFunctionExpression(init) || import_core3.types.isArrowFunctionExpression(init)) && path.parent.kind === "const";
   const importName = isComputed ? "computed" : "signal";
   const state = path.state;
   const args = init ? [init] : [];
-  const newInit = import_core5.types.callExpression(import_core5.types.identifier(state.imports[importName].name), args);
+  const newInit = import_core3.types.callExpression(import_core3.types.identifier(state.imports[importName].name), args);
   addImport(importName);
   path.node.init = newInit;
 }
 function isAlreadySignalCall(init) {
-  if (!init || !import_core5.types.isCallExpression(init) || !import_core5.types.isIdentifier(init.callee)) {
+  if (!init || !import_core3.types.isCallExpression(init) || !import_core3.types.isIdentifier(init.callee)) {
     return false;
   }
   const calleeName = init.callee.name;
@@ -561,7 +337,11 @@ function symbolIdentifier(path) {
   if (isAlreadyValueAccess(path)) {
     return;
   }
-  path.replaceWith(import_core5.types.memberExpression(import_core5.types.identifier(name), import_core5.types.identifier("value")));
+  const parent = path.parent;
+  if (import_core3.types.isMemberExpression(parent) && parent.property === path.node) {
+    return;
+  }
+  path.replaceWith(import_core3.types.memberExpression(import_core3.types.identifier(name), import_core3.types.identifier("value")));
 }
 function shouldProcessIdentifier(path, parentPath) {
   if (!parentPath) {
@@ -569,38 +349,38 @@ function shouldProcessIdentifier(path, parentPath) {
   }
   const parent = parentPath.node;
   const currentNode = path.node;
-  if (import_core5.types.isVariableDeclarator(parent) || import_core5.types.isArrayPattern(parent) || import_core5.types.isObjectPattern(parent)) {
+  if (import_core3.types.isVariableDeclarator(parent) || import_core3.types.isArrayPattern(parent) || import_core3.types.isObjectPattern(parent)) {
     return false;
   }
-  if (import_core5.types.isImportSpecifier(parent) || import_core5.types.isImportDefaultSpecifier(parent) || import_core5.types.isImportNamespaceSpecifier(parent)) {
+  if (import_core3.types.isImportSpecifier(parent) || import_core3.types.isImportDefaultSpecifier(parent) || import_core3.types.isImportNamespaceSpecifier(parent)) {
     return false;
   }
-  if (import_core5.types.isFunctionDeclaration(parent) || import_core5.types.isFunctionExpression(parent) || import_core5.types.isArrowFunctionExpression(parent)) {
+  if (import_core3.types.isFunctionDeclaration(parent) || import_core3.types.isFunctionExpression(parent) || import_core3.types.isArrowFunctionExpression(parent)) {
     return false;
   }
-  if (import_core5.types.isClassDeclaration(parent) && parent.id === currentNode) {
+  if (import_core3.types.isClassDeclaration(parent) && parent.id === currentNode) {
     return false;
   }
-  if (import_core5.types.isObjectMethod(parent) || import_core5.types.isClassMethod(parent)) {
+  if (import_core3.types.isObjectMethod(parent) || import_core3.types.isClassMethod(parent)) {
     return false;
   }
-  if (import_core5.types.isObjectProperty(parent) && parent.key === currentNode) {
+  if (import_core3.types.isObjectProperty(parent) && parent.key === currentNode) {
     return false;
   }
-  if (import_core5.types.isLabeledStatement(parent) && parent.label === currentNode) {
+  if (import_core3.types.isLabeledStatement(parent) && parent.label === currentNode) {
     return false;
   }
-  if ((import_core5.types.isBreakStatement(parent) || import_core5.types.isContinueStatement(parent)) && parent.label === currentNode) {
+  if ((import_core3.types.isBreakStatement(parent) || import_core3.types.isContinueStatement(parent)) && parent.label === currentNode) {
     return false;
   }
   return true;
 }
 function isAlreadyValueAccess(path) {
   const parent = path.parent;
-  if (import_core5.types.isMemberExpression(parent) && parent.object === path.node) {
+  if (import_core3.types.isMemberExpression(parent) && parent.object === path.node) {
     return isMemberAccessingProperty(parent, "value");
   }
-  if (!import_core5.types.isParenthesizedExpression(parent) && !import_core5.types.isTSAsExpression(parent) && !import_core5.types.isTSNonNullExpression(parent)) {
+  if (!import_core3.types.isParenthesizedExpression(parent) && !import_core3.types.isTSAsExpression(parent) && !import_core3.types.isTSNonNullExpression(parent)) {
     return false;
   }
   const ancestorCheck = path.findParent((p) => {
@@ -617,7 +397,7 @@ function symbolAssignment(path) {
     return;
   }
   const { left } = path.node;
-  if (!import_core5.types.isIdentifier(left)) {
+  if (!import_core3.types.isIdentifier(left)) {
     return;
   }
   const name = left.name;
@@ -627,17 +407,17 @@ function symbolAssignment(path) {
   if (isAlreadyValueAssignment(left)) {
     return;
   }
-  path.node.left = import_core5.types.memberExpression(import_core5.types.identifier(name), import_core5.types.identifier("value"));
+  path.node.left = import_core3.types.memberExpression(import_core3.types.identifier(name), import_core3.types.identifier("value"));
 }
 function isAlreadyValueAssignment(left) {
-  return import_core5.types.isMemberExpression(left) && isMemberAccessingProperty(left, "value");
+  return import_core3.types.isMemberExpression(left) && isMemberAccessingProperty(left, "value");
 }
 function symbolUpdate(path) {
   if (!isValidPath(path)) {
     return;
   }
   const { argument } = path.node;
-  if (!import_core5.types.isIdentifier(argument)) {
+  if (!import_core3.types.isIdentifier(argument)) {
     return;
   }
   const name = argument.name;
@@ -647,10 +427,10 @@ function symbolUpdate(path) {
   if (isAlreadyValueUpdate(argument)) {
     return;
   }
-  path.node.argument = import_core5.types.memberExpression(import_core5.types.identifier(name), import_core5.types.identifier("value"));
+  path.node.argument = import_core3.types.memberExpression(import_core3.types.identifier(name), import_core3.types.identifier("value"));
 }
 function isAlreadyValueUpdate(argument) {
-  return import_core5.types.isMemberExpression(argument) && isMemberAccessingProperty(argument, "value");
+  return import_core3.types.isMemberExpression(argument) && isMemberAccessingProperty(argument, "value");
 }
 function symbolObjectPattern(path) {
   if (!isValidPath(path)) {
@@ -662,9 +442,9 @@ function symbolObjectPattern(path) {
   }
   for (const property of properties) {
     if (!property) continue;
-    if (import_core5.types.isObjectProperty(property)) {
+    if (import_core3.types.isObjectProperty(property)) {
       handleObjectProperty(property, path);
-    } else if (import_core5.types.isRestElement(property)) {
+    } else if (import_core3.types.isRestElement(property)) {
       handleRestElement(property, path);
     }
   }
@@ -674,34 +454,34 @@ function handleObjectProperty(property, parentPath) {
     return;
   }
   const value = property.value;
-  if (import_core5.types.isObjectPattern(value)) {
+  if (import_core3.types.isObjectPattern(value)) {
     const mockPath = {
       node: value,
       state: parentPath.state,
       parentPath
     };
     symbolObjectPattern(mockPath);
-  } else if (import_core5.types.isArrayPattern(value)) {
+  } else if (import_core3.types.isArrayPattern(value)) {
     const mockPath = {
       node: value,
       state: parentPath.state,
       parentPath
     };
     symbolArrayPattern(mockPath);
-  } else if (import_core5.types.isAssignmentPattern(value)) {
+  } else if (import_core3.types.isAssignmentPattern(value)) {
     handleAssignmentPattern(value, parentPath);
   }
 }
 function handleAssignmentPattern(pattern, parentPath) {
   const left = pattern.left;
-  if (import_core5.types.isObjectPattern(left)) {
+  if (import_core3.types.isObjectPattern(left)) {
     const mockPath = {
       node: left,
       state: parentPath.state,
       parentPath
     };
     symbolObjectPattern(mockPath);
-  } else if (import_core5.types.isArrayPattern(left)) {
+  } else if (import_core3.types.isArrayPattern(left)) {
     const mockPath = {
       node: left,
       state: parentPath.state,
@@ -715,14 +495,14 @@ function handleRestElement(restElement, parentPath) {
     return;
   }
   const argument = restElement.argument;
-  if (import_core5.types.isObjectPattern(argument)) {
+  if (import_core3.types.isObjectPattern(argument)) {
     const mockPath = {
       node: argument,
       state: parentPath.state,
       parentPath
     };
     symbolObjectPattern(mockPath);
-  } else if (import_core5.types.isArrayPattern(argument)) {
+  } else if (import_core3.types.isArrayPattern(argument)) {
     const mockPath = {
       node: argument,
       state: parentPath.state,
@@ -741,18 +521,18 @@ function symbolArrayPattern(path) {
   }
   for (const element of elements) {
     if (!element) continue;
-    if (import_core5.types.isAssignmentPattern(element)) {
+    if (import_core3.types.isAssignmentPattern(element)) {
       handleAssignmentPattern(element, path);
-    } else if (import_core5.types.isRestElement(element)) {
+    } else if (import_core3.types.isRestElement(element)) {
       handleArrayRestElement(element, path);
-    } else if (import_core5.types.isObjectPattern(element)) {
+    } else if (import_core3.types.isObjectPattern(element)) {
       const mockPath = {
         node: element,
         state: path.state,
         parentPath: path
       };
       symbolObjectPattern(mockPath);
-    } else if (import_core5.types.isArrayPattern(element)) {
+    } else if (import_core3.types.isArrayPattern(element)) {
       const mockPath = {
         node: element,
         state: path.state,
@@ -767,14 +547,14 @@ function handleArrayRestElement(restElement, parentPath) {
     return;
   }
   const argument = restElement.argument;
-  if (import_core5.types.isArrayPattern(argument)) {
+  if (import_core3.types.isArrayPattern(argument)) {
     const mockPath = {
       node: argument,
       state: parentPath.state,
       parentPath
     };
     symbolArrayPattern(mockPath);
-  } else if (import_core5.types.isObjectPattern(argument)) {
+  } else if (import_core3.types.isObjectPattern(argument)) {
     const mockPath = {
       node: argument,
       state: parentPath.state,
@@ -784,6 +564,251 @@ function handleArrayRestElement(restElement, parentPath) {
   }
 }
 
+// src/program.ts
+function withState(visitor, parentState) {
+  return (path) => {
+    path.state = parentState;
+    visitor(path);
+  };
+}
+var transformProgram = {
+  enter: (path, state) => {
+    const opts = __spreadValues(__spreadValues({}, DEFAULT_OPTIONS), state.opts);
+    const imports = createImportIdentifiers(path);
+    clearImport();
+    path.state = __spreadProps(__spreadValues({}, state), {
+      opts,
+      imports,
+      declarations: [],
+      // Collect template declarations during transformation
+      filename: state.filename,
+      events: /* @__PURE__ */ new Set()
+      // Track delegated events for optimization
+    });
+    const parentState = path.state;
+    path.traverse({
+      VariableDeclarator: withState(replaceSymbol, parentState),
+      // let $x = 0 → let $x = signal(0)
+      Identifier: withState(symbolIdentifier, parentState),
+      // $x → $x.value
+      AssignmentExpression: withState(symbolAssignment, parentState),
+      // $x = 1 → $x.value = 1
+      UpdateExpression: withState(symbolUpdate, parentState),
+      // $x++ → $x.value++
+      ObjectPattern: withState(symbolObjectPattern, parentState),
+      // { $x } → handle nested patterns
+      ArrayPattern: withState(symbolArrayPattern, parentState)
+      // [$x] → handle nested patterns
+    });
+  },
+  // eslint-disable-next-line unused-imports/no-unused-vars
+  exit: (path, state) => {
+    const pluginState = path.state;
+    const { imports, declarations, events } = pluginState;
+    const insertIndex = path.node.body.findIndex(
+      (node) => !import_core4.types.isImportDeclaration(node) && !import_core4.types.isExportDeclaration(node)
+    );
+    if (declarations == null ? void 0 : declarations.length) {
+      const templateDeclaration = import_core4.types.variableDeclaration("const", declarations);
+      if (insertIndex !== -1) {
+        path.node.body.splice(insertIndex, 0, templateDeclaration);
+      } else {
+        path.node.body.push(templateDeclaration);
+      }
+    }
+    if (events && events.size > 0) {
+      const eventsDeclaration = import_core4.types.expressionStatement(
+        import_core4.types.callExpression(imports.delegateEvents, [
+          import_core4.types.arrayExpression(Array.from(events).map((event) => import_core4.types.stringLiteral(event)))
+        ])
+      );
+      addImport(importMap.delegateEvents);
+      path.node.body.push(eventsDeclaration);
+    }
+    createImport(path, imports, "essor");
+  }
+};
+
+// src/signals/props.ts
+var import_core5 = require("@babel/core");
+function transformProperty(path, properties, parentPath, defaultValues = {}) {
+  properties.forEach((property, index) => {
+    try {
+      if (!import_core5.types.isObjectProperty(property)) {
+        return;
+      }
+      if (!import_core5.types.isIdentifier(property.key)) {
+        if (true) {
+          ne("transformObjectProperties: Skipping computed property", { index });
+        }
+        return;
+      }
+      const keyName = property.key.name;
+      if (import_core5.types.isIdentifier(property.value)) {
+        path.scope.rename(property.value.name, `${parentPath}.${keyName}`);
+      } else if (import_core5.types.isAssignmentPattern(property.value)) {
+        if (import_core5.types.isIdentifier(property.value.left)) {
+          defaultValues[keyName] = property.value.right;
+          path.scope.rename(property.value.left.name, `${parentPath}.${keyName}`);
+        } else if (import_core5.types.isObjectPattern(property.value.left)) {
+          transformProperty(
+            path,
+            property.value.left.properties,
+            `${parentPath}.${keyName}`,
+            defaultValues
+          );
+          defaultValues[keyName] = property.value.right;
+        }
+      } else if (import_core5.types.isObjectPattern(property.value)) {
+        transformProperty(
+          path,
+          property.value.properties,
+          `${parentPath}.${keyName}`,
+          defaultValues
+        );
+      }
+    } catch (error) {
+      ne("transformProperty", `Failed to process property at index ${index}`, {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  });
+  return defaultValues;
+}
+function buildRestVariableDeclaration(state, restName, parentPath, excludeProps) {
+  const validExcludeProps = excludeProps.filter(Boolean);
+  let init;
+  const pathParts = parentPath.split(".").filter((part) => part.length > 0);
+  let sourceObject = import_core5.types.identifier(pathParts[0] || "__props");
+  for (let i = 1; i < pathParts.length; i++) {
+    sourceObject = import_core5.types.memberExpression(sourceObject, import_core5.types.identifier(pathParts[i]));
+  }
+  if (validExcludeProps.length === 0) {
+    init = sourceObject;
+  } else {
+    init = import_core5.types.callExpression(state.imports.omitProps, [
+      sourceObject,
+      import_core5.types.arrayExpression(validExcludeProps.map((name) => import_core5.types.stringLiteral(name)))
+    ]);
+  }
+  return import_core5.types.variableDeclaration("const", [import_core5.types.variableDeclarator(import_core5.types.identifier(restName), init)]);
+}
+function transformRestProperties(path, restProperties, notRestNames = [], nestedRestParams = []) {
+  if (!import_core5.types.isIdentifier(restProperties.argument)) {
+    return;
+  }
+  const restName = restProperties.argument.name;
+  if (notRestNames.length === 0 && nestedRestParams.length === 0) {
+    path.node.params[0] = import_core5.types.identifier(restName);
+  } else {
+    const restDeclarations = [];
+    if (nestedRestParams.length > 0) {
+      for (const nestedRest of nestedRestParams) {
+        const nestedRestDeclaration = buildRestVariableDeclaration(
+          path.state,
+          nestedRest.name,
+          nestedRest.parentPath,
+          nestedRest.excludeProps
+        );
+        restDeclarations.push(nestedRestDeclaration);
+        if (nestedRest.excludeProps.length > 0) {
+          addImport(importMap.omitProps);
+        }
+      }
+    }
+    if (restProperties) {
+      const restDeclaration = buildRestVariableDeclaration(
+        path.state,
+        restName,
+        TRANSFORM_PROPERTY_NAME,
+        notRestNames
+      );
+      restDeclarations.push(restDeclaration);
+      if (notRestNames.length) {
+        addImport(importMap.omitProps);
+      }
+    }
+    for (const declaration of restDeclarations) {
+      const body = path.node.body;
+      body.body.unshift(declaration);
+    }
+  }
+}
+function buildDefaultValueObject(defaultValues) {
+  if (!P(defaultValues)) {
+    return import_core5.types.objectExpression([]);
+  }
+  const properties = [];
+  for (const [key, value] of Object.entries(defaultValues)) {
+    if (!key) {
+      continue;
+    }
+    let propertyValue;
+    if (P(value) && !import_core5.types.isNode(value)) {
+      propertyValue = buildDefaultValueObject(value);
+    } else if (import_core5.types.isExpression(value)) {
+      propertyValue = value;
+    } else {
+      continue;
+    }
+    properties.push(import_core5.types.objectProperty(import_core5.types.identifier(key), propertyValue));
+  }
+  return import_core5.types.objectExpression(properties);
+}
+function buildDefaultValue(path, defaultValues) {
+  const propsParam = Object.keys(defaultValues).length > 0 ? import_core5.types.assignmentPattern(
+    import_core5.types.identifier(TRANSFORM_PROPERTY_NAME),
+    buildDefaultValueObject(defaultValues)
+  ) : import_core5.types.identifier(TRANSFORM_PROPERTY_NAME);
+  path.node.params[0] = propsParam;
+}
+function transformProps(path) {
+  const firstParam = path.node.params[0];
+  if (!firstParam || !import_core5.types.isObjectPattern(firstParam) || !checkHasJSXReturn(path)) {
+    return;
+  }
+  const state = path.state;
+  const properties = firstParam.properties;
+  const signalPrefix = state.opts.symbol || "$";
+  const notRestProperties = properties.filter((prop) => !import_core5.types.isRestElement(prop));
+  const restProperties = properties.find((prop) => import_core5.types.isRestElement(prop));
+  const notRestNames = notRestProperties.map((prop) => import_core5.types.isIdentifier(prop.key) ? prop.key.name : null).filter((name) => name !== null);
+  if (true) {
+    if (notRestNames.some((name) => q(name, signalPrefix))) {
+      ne(
+        "transformProps",
+        "Property names cannot start with signal prefix",
+        notRestNames.filter((name) => q(name, signalPrefix))
+      );
+    }
+  }
+  if (notRestProperties.length) {
+    const defaultValues = transformProperty(path, notRestProperties, TRANSFORM_PROPERTY_NAME);
+    buildDefaultValue(path, defaultValues);
+  }
+  if (restProperties) {
+    transformRestProperties(path, restProperties, notRestNames);
+  }
+}
+
+// src/jsx/context.ts
+var contextStack = [];
+function getContext() {
+  if (!contextStack.length) {
+    throw new Error("No active context found. Ensure setContext has been called.");
+  }
+  return contextStack[contextStack.length - 1];
+}
+function setContext(context) {
+  contextStack.push(context);
+}
+function resetContext() {
+  contextStack.pop();
+}
+
+// src/jsx/client.ts
+var import_core8 = require("@babel/core");
+
 // src/jsx/constants.ts
 var CLASS_NAME = "class";
 var STYLE_NAME = "style";
@@ -791,6 +816,7 @@ var EVENT_ATTR_NAME = "on";
 var UPDATE_PREFIX = "update";
 var FRAGMENT_NAME = "Fragment";
 var CHILDREN_NAME = "children";
+var REF_KEY = "ref";
 var SPREAD_NAME = "_$spread$";
 var CREATE_COMPONENT_NAME = "createComponent";
 var BIND_REG = /^bind:.+/;
@@ -821,15 +847,17 @@ function isTreeNode(node) {
 var treeIndex = 1;
 function createTree(path, parentNode) {
   const treeNode = createDefaultTree();
+  const tagName = getTagName(path.node);
+  treeNode.tag = tagName;
+  treeNode.type = determineNodeType(tagName);
+  treeNode.selfClosing = Ne(tagName);
   if (parentNode) {
-    const nodeInfo = path.node;
-    const isBuiltInComponent = BUILT_IN_COMPONENTS.includes(parentNode.tag);
-    const isComponentOrFragment = isComponentName(getTagName(nodeInfo));
-    if (!isComponentOrFragment && !isBuiltInComponent) {
-      treeNode.index = ++treeIndex;
-    }
-    if (isBuiltInComponent) {
+    const parentIsComponent = parentNode.type === 1 /* COMPONENT */;
+    if (parentIsComponent) {
       treeIndex = 1;
+      treeNode.index = treeIndex;
+    } else if (treeNode.type !== 1 /* COMPONENT */) {
+      treeNode.index = ++treeIndex;
     }
     treeNode.parentIndex = treeIndex;
   } else {
@@ -845,10 +873,6 @@ function createTree(path, parentNode) {
   return treeNode;
 }
 function processJSXElement(path, treeNode) {
-  const tagName = getTagName(path.node);
-  treeNode.tag = tagName;
-  treeNode.type = determineNodeType(tagName);
-  treeNode.selfClosing = Ne(tagName);
   if (!path.isJSXFragment()) {
     treeNode.props = processProps(path);
   }
@@ -1488,7 +1512,7 @@ function transformJSXToClient(path, node) {
       ])
     );
   }
-  if (dynamicCollection.children.length || dynamicCollection.props.length) {
+  if (dynamicCollection.children.length || dynamicCollection.props.length || dynamicCollection.operations.length) {
     addImport(importMap.mapNodes);
     statements.push(
       import_core8.types.variableDeclaration("const", [
@@ -1584,6 +1608,22 @@ function generateIndexMap({
   }
   return indexMap;
 }
+function createRefStatement(nodesId, nodeIndex, value) {
+  const elementRef = import_core8.types.memberExpression(nodesId, import_core8.types.numericLiteral(nodeIndex), true);
+  const typeofCheck = import_core8.types.binaryExpression(
+    "===",
+    import_core8.types.unaryExpression("typeof", value),
+    import_core8.types.stringLiteral("function")
+  );
+  const functionCall = import_core8.types.callExpression(value, [elementRef]);
+  const assignmentExpr = import_core8.types.assignmentExpression(
+    "=",
+    import_core8.types.memberExpression(value, import_core8.types.identifier("value")),
+    elementRef
+  );
+  const conditionalExpr = import_core8.types.conditionalExpression(typeofCheck, functionCall, assignmentExpr);
+  return import_core8.types.expressionStatement(conditionalExpr);
+}
 function createAttributeStatement(functionIdentifier, nodesId, nodeIndex, value, key) {
   const args = [import_core8.types.memberExpression(nodesId, import_core8.types.numericLiteral(nodeIndex), true)];
   if (key) {
@@ -1641,6 +1681,9 @@ function generateSpecificAttributeCode(attributeName, attributeValue, nodesId, n
         createAttributeStatement(state.imports.setSpread, nodesId, nodeIndex, attributeValue)
       );
       break;
+    case REF_KEY:
+      statements.push(createRefStatement(nodesId, nodeIndex, attributeValue));
+      break;
     case STYLE_NAME:
       addImport(importMap.patchStyle);
       statements.push(
@@ -1791,10 +1834,7 @@ function generateDynamicPropsCode(dynamicProps, statements, state, nodesId, inde
 function generateUnifiedMemoizedEffect(reactiveOperations, statements, state, nodesId, indexMap) {
   addImport(importMap.memoEffect);
   const variableDeclarations = reactiveOperations.map((op, index) => {
-    let attrValue = op.attrValue;
-    if (import_core8.types.isIdentifier(op.attrValue) && isSignal(op.attrValue.name)) {
-      attrValue = import_core8.types.memberExpression(attrValue, import_core8.types.identifier("value"));
-    }
+    const attrValue = op.attrValue;
     return import_core8.types.variableDeclarator(import_core8.types.identifier(`_v$${index}`), attrValue);
   });
   const updateStatements = reactiveOperations.map((op, index) => {
@@ -1964,7 +2004,7 @@ function processNodeDynamic(dynamicCollection, node, parentNode) {
       if (node.props && Object.keys(node.props).length > 0) {
         const currentProps = {};
         for (const [attrName, attrValue] of Object.entries(node.props)) {
-          const isReactive = import_core8.types.isNode(attrValue) && isDynamicExpression(attrValue) && !q(attrName, `${UPDATE_PREFIX}:`) && !q(attrName, EVENT_ATTR_NAME);
+          const isReactive = import_core8.types.isNode(attrValue) && isDynamicExpression(attrValue) && !q(attrName, `${UPDATE_PREFIX}:`) && !q(attrName, EVENT_ATTR_NAME) && attrName !== REF_KEY;
           if (q(attrName, `${UPDATE_PREFIX}:`)) {
             const name = attrName.split(":")[1];
             const setFunction = getSetFunctionForAttribute();
@@ -2286,19 +2326,6 @@ function index_default() {
       // props
       FunctionDeclaration: transformProps,
       ArrowFunctionExpression: transformProps,
-      // Symbol
-      VariableDeclarator: replaceSymbol,
-      // let $x = 0 → let $x = signal(0)
-      Identifier: symbolIdentifier,
-      // $x → $x.value
-      AssignmentExpression: symbolAssignment,
-      // $x = 1 → $x.value = 1
-      UpdateExpression: symbolUpdate,
-      // $x++ → $x.value++
-      ObjectPattern: symbolObjectPattern,
-      // { $x } → handle nested patterns
-      ArrayPattern: symbolArrayPattern,
-      // [$x] → handle nested patterns
       // JSX
       JSXElement: transformJSX,
       JSXFragment: transformJSX