@oddo/lang 0.0.7 → 0.0.8

package/dist/index.js

@@ -3586,71 +3586,6 @@ var traverse = _traverse3.default.default || _traverse3.default;
 function isValidJSIdentifier(name) {
   return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
-function extractIdentifiers(babelNode) {
-  const identifiers = /* @__PURE__ */ new Set();
-  const locals = /* @__PURE__ */ new Set();
-  function traverse2(node) {
-    var _a, _b, _c;
-    if (!node) return;
-    if (t.isIdentifier(node)) {
-      if (!locals.has(node.name) && !node.name.startsWith("__ODDO_IMPORT_")) {
-        identifiers.add(node.name);
-      }
-    } else if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
-      traverse2(node.object);
-      if (node.computed) traverse2(node.property);
-    } else if (t.isCallExpression(node) || t.isOptionalCallExpression(node)) {
-      traverse2(node.callee);
-      (_a = node.arguments) == null ? void 0 : _a.forEach((arg) => traverse2(arg));
-    } else if (t.isBinaryExpression(node) || t.isLogicalExpression(node)) {
-      traverse2(node.left);
-      traverse2(node.right);
-    } else if (t.isUnaryExpression(node)) {
-      traverse2(node.argument);
-    } else if (t.isConditionalExpression(node)) {
-      traverse2(node.test);
-      traverse2(node.consequent);
-      traverse2(node.alternate);
-    } else if (t.isArrayExpression(node)) {
-      (_b = node.elements) == null ? void 0 : _b.forEach((el) => traverse2(el));
-    } else if (t.isObjectExpression(node)) {
-      (_c = node.properties) == null ? void 0 : _c.forEach((prop) => {
-        if (t.isObjectProperty(prop)) {
-          if (prop.computed) traverse2(prop.key);
-          traverse2(prop.value);
-        } else if (t.isSpreadElement(prop)) {
-          traverse2(prop.argument);
-        }
-      });
-    } else if (t.isArrowFunctionExpression(node)) {
-      node.params.forEach((p) => {
-        var _a2;
-        if (t.isIdentifier(p)) locals.add(p.name);
-        else if (t.isObjectPattern(p)) p.properties.forEach((prop) => t.isIdentifier(prop.value) && locals.add(prop.value.name));
-        else if (t.isArrayPattern(p)) (_a2 = p.elements) == null ? void 0 : _a2.forEach((el) => t.isIdentifier(el) && locals.add(el.name));
-      });
-      if (t.isBlockStatement(node.body)) node.body.body.forEach((s) => traverse2(s));
-      else traverse2(node.body);
-    } else if (t.isBlockStatement(node)) {
-      node.body.forEach((s) => traverse2(s));
-    } else if (t.isExpressionStatement(node)) {
-      traverse2(node.expression);
-    } else if (t.isReturnStatement(node)) {
-      traverse2(node.argument);
-    } else if (t.isSequenceExpression(node)) {
-      node.expressions.forEach((expr) => traverse2(expr));
-    } else if (t.isUpdateExpression(node)) {
-      traverse2(node.argument);
-    } else if (t.isAssignmentExpression(node)) {
-      traverse2(node.left);
-      traverse2(node.right);
-    } else if (t.isSpreadElement(node)) {
-      traverse2(node.argument);
-    }
-  }
-  traverse2(babelNode);
-  return Array.from(identifiers);
-}
 function wrapDependenciesWithCalls(arrowFunc, deps) {
   const depSet = new Set(deps);
   const locals = /* @__PURE__ */ new Set();
@@ -3734,9 +3669,9 @@ function createLiftedExpr(valueExpr, identifiers) {
     [arrowFunc, t.arrayExpression(depsArray)]
   );
 }
-function createReactiveExpr(valueExpr, attrExpression = false) {
-  const allIdentifiers = extractIdentifiers(valueExpr);
-  const identifiers = getReactiveDeps(allIdentifiers);
+function createReactiveExpr(oddoExpr, valueExpr, attrExpression = false) {
+  const allIdentifiers = collectOddoIdentifiersOnly(oddoExpr);
+  const identifiers = allIdentifiers.filter((id) => isReactive(id));
   const pragma = attrExpression ? "computed" : "x";
   if (identifiers.length === 0) {
     if (t.isLiteral(valueExpr)) {
@@ -3789,9 +3724,11 @@ var MODIFIER_TRANSFORMATIONS = {
   computed: {
     needsImport: true,
     // @computed sum = x + y -> const sum = _computed((x, y) => x() + y(), [x, y])
-    transform: (valueExpr, leftExpr) => {
-      const allIds = extractIdentifiers(valueExpr);
-      const identifiers = getReactiveDeps(allIds);
+    // Receives Oddo AST, extracts deps from Oddo, converts internally
+    transform: (oddoExpr, leftExpr) => {
+      const allIds = collectOddoIdentifiersOnly(oddoExpr);
+      const identifiers = allIds.filter((id) => isReactive(id));
+      const valueExpr = convertExpression2(oddoExpr);
       const params = identifiers.map((id) => t.identifier(id));
       const deps = identifiers.map((id) => t.identifier(id));
       const arrowFunc = t.arrowFunctionExpression(params, valueExpr);
@@ -3808,28 +3745,6 @@ var MODIFIER_TRANSFORMATIONS = {
       return t.expressionStatement(computedCall);
     }
   },
-  react: {
-    needsImport: true,
-    // @react sum = x + y -> const sum = _react((x, y) => x() + y(), [x, y])
-    transform: (valueExpr, leftExpr) => {
-      const allIds = extractIdentifiers(valueExpr);
-      const identifiers = getReactiveDeps(allIds);
-      const params = identifiers.map((id) => t.identifier(id));
-      const deps = identifiers.map((id) => t.identifier(id));
-      const arrowFunc = t.arrowFunctionExpression(params, valueExpr);
-      wrapDependenciesWithCalls(arrowFunc, identifiers);
-      const reactCall = t.callExpression(
-        t.identifier(modifierAliases["react"]),
-        [arrowFunc, t.arrayExpression(deps)]
-      );
-      if (leftExpr) {
-        return t.variableDeclaration("const", [
-          t.variableDeclarator(leftExpr, reactCall)
-        ]);
-      }
-      return t.expressionStatement(reactCall);
-    }
-  },
   mutate: {
     needsImport: true,
     // @mutate x = (arg1, arg2) => { x1 := value1; x2 := value2 }
@@ -4028,16 +3943,52 @@ var MODIFIER_TRANSFORMATIONS = {
     needsImport: false,
     // @mutable x = 3 -> let x = 3;
     // @mutable x = y + 1 (y is @state) -> let x = _lift((y) => y() + 1, [y])
-    transform: (valueExpr, leftExpr) => {
+    // Receives Oddo AST, extracts deps from Oddo, converts internally
+    transform: (oddoExpr, leftExpr) => {
       if (leftExpr && t.isIdentifier(leftExpr)) {
         mutableVariables.add(leftExpr.name);
-        const identifiers = extractIdentifiers(valueExpr);
+        const identifiers = collectOddoIdentifiersOnly(oddoExpr);
+        const valueExpr = convertExpression2(oddoExpr);
         const liftedExpr = createLiftedExpr(valueExpr, identifiers);
         return t.variableDeclaration("let", [
           t.variableDeclarator(leftExpr, liftedExpr || valueExpr)
         ]);
       }
-      return t.expressionStatement(valueExpr);
+      return t.expressionStatement(convertExpression2(oddoExpr));
+    }
+  },
+  component: {
+    needsImport: false,
+    // @component Counter = (props) => { ... } -> const Counter = function(props) { ... }
+    // Parameters are treated as reactive, no _liftFn wrapping, compiles to regular function
+    transform: (oddoExpr, leftExpr) => {
+      if (oddoExpr.type !== "arrowFunction") {
+        throw new Error("@component modifier must be applied to an arrow function");
+      }
+      const funcExpr = convertReactiveContainer(oddoExpr);
+      if (leftExpr && t.isIdentifier(leftExpr)) {
+        return t.variableDeclaration("const", [
+          t.variableDeclarator(leftExpr, funcExpr)
+        ]);
+      }
+      return t.expressionStatement(funcExpr);
+    }
+  },
+  hook: {
+    needsImport: false,
+    // @hook useCounter = (initial) => { ... } -> const useCounter = function(initial) { ... }
+    // Parameters are treated as reactive, no _liftFn wrapping, compiles to regular function
+    transform: (oddoExpr, leftExpr) => {
+      if (oddoExpr.type !== "arrowFunction") {
+        throw new Error("@hook modifier must be applied to an arrow function");
+      }
+      const funcExpr = convertReactiveContainer(oddoExpr);
+      if (leftExpr && t.isIdentifier(leftExpr)) {
+        return t.variableDeclaration("const", [
+          t.variableDeclarator(leftExpr, funcExpr)
+        ]);
+      }
+      return t.expressionStatement(funcExpr);
     }
   }
 };
@@ -4197,7 +4148,7 @@ function compileToJS(ast, config = {}) {
   moduleScope = null;
   currentScope = null;
   usedNames = collectOddoIdentifiers(ast);
-  const allImports = ["state", "computed", "react", "mutate", "effect", "stateProxy", "lift", "liftFn", "e", "c", "x", "f"];
+  const allImports = ["state", "computed", "mutate", "effect", "stateProxy", "lift", "liftFn", "e", "c", "x", "f"];
   for (const name of allImports) {
     modifierAliases[name] = `__ODDO_IMPORT_${name}__`;
   }
@@ -4297,13 +4248,13 @@ function convertExpressionStatement2(stmt) {
       let leftExpr = null;
       if (stmt.expression.type === "variableDeclaration" || stmt.expression.type === "assignment") {
         leftExpr = convertExpression2(stmt.expression.left);
-        if (stmt.modifier === "mutate" || stmt.modifier === "effect") {
+        if (stmt.modifier === "mutate" || stmt.modifier === "effect" || stmt.modifier === "computed" || stmt.modifier === "mutable" || stmt.modifier === "component" || stmt.modifier === "hook") {
           valueExpr = stmt.expression.right;
         } else {
           valueExpr = convertExpression2(stmt.expression.right);
         }
       } else {
-        if (stmt.modifier === "mutate" || stmt.modifier === "effect") {
+        if (stmt.modifier === "mutate" || stmt.modifier === "effect" || stmt.modifier === "computed" || stmt.modifier === "mutable" || stmt.modifier === "component" || stmt.modifier === "hook") {
           valueExpr = stmt.expression;
         } else {
           valueExpr = convertExpression2(stmt.expression);
@@ -4324,13 +4275,13 @@ function convertExpressionStatement2(stmt) {
           let leftExpr = null;
           if (blockStmt.expression.type === "variableDeclaration" || blockStmt.expression.type === "assignment") {
             leftExpr = convertExpression2(blockStmt.expression.left);
-            if (stmt.modifier === "mutate" || stmt.modifier === "effect") {
+            if (stmt.modifier === "mutate" || stmt.modifier === "effect" || stmt.modifier === "computed" || stmt.modifier === "mutable" || stmt.modifier === "component" || stmt.modifier === "hook") {
               valueExpr = blockStmt.expression.right;
             } else {
               valueExpr = convertExpression2(blockStmt.expression.right);
             }
           } else {
-            if (stmt.modifier === "mutate" || stmt.modifier === "effect") {
+            if (stmt.modifier === "mutate" || stmt.modifier === "effect" || stmt.modifier === "computed" || stmt.modifier === "mutable" || stmt.modifier === "component" || stmt.modifier === "hook") {
               valueExpr = blockStmt.expression;
             } else {
               valueExpr = convertExpression2(blockStmt.expression);
@@ -4349,11 +4300,18 @@ function convertExpressionStatement2(stmt) {
   }
   if (stmt.expression && stmt.expression.type === "variableDeclaration") {
     const left = convertExpression2(stmt.expression.left);
-    const right = convertExpression2(stmt.expression.right);
-    const identifiers = extractIdentifiers(right);
-    const liftedExpr = createLiftedExpr(right, identifiers);
+    const oddoRight = stmt.expression.right;
+    const right = convertExpression2(oddoRight);
+    let finalExpr = right;
+    if (oddoRight.type !== "arrowFunction") {
+      const identifiers = collectOddoIdentifiersOnly(oddoRight);
+      const liftedExpr = createLiftedExpr(right, identifiers);
+      if (liftedExpr) {
+        finalExpr = liftedExpr;
+      }
+    }
     return t.variableDeclaration("const", [
-      t.variableDeclarator(left, liftedExpr || right)
+      t.variableDeclarator(left, finalExpr)
     ]);
   }
   let expression = null;
@@ -4553,6 +4511,58 @@ function convertArrowFunction2(expr) {
   }
   return t.arrowFunctionExpression(params, body);
 }
+function convertReactiveContainer(expr) {
+  var _a;
+  const savedScope = currentScope;
+  if (expr._scope) {
+    currentScope = expr._scope;
+  } else {
+    currentScope = Object.create(savedScope);
+  }
+  for (const param of expr.parameters || []) {
+    if (param.name) {
+      currentScope[param.name] = { type: "param", reactive: true };
+    } else if (param.type === "destructuringPattern") {
+      const boundNames = extractBoundNames(param.pattern);
+      for (const name of boundNames) {
+        currentScope[name] = { type: "param", reactive: true };
+      }
+    } else if (param.type === "restElement" && ((_a = param.argument) == null ? void 0 : _a.name)) {
+      currentScope[param.argument.name] = { type: "param", reactive: true };
+    }
+  }
+  const params = (expr.parameters || []).map((param) => {
+    if (param.type === "restElement") {
+      return t.restElement(convertExpression2(param.argument));
+    }
+    if (param.type === "destructuringPattern") {
+      const pattern = convertExpression2(param.pattern);
+      if (param.default) {
+        return t.assignmentPattern(pattern, convertExpression2(param.default));
+      }
+      return pattern;
+    }
+    if (param.type === "parameter") {
+      const paramId = t.identifier(param.name);
+      if (param.default) {
+        return t.assignmentPattern(paramId, convertExpression2(param.default));
+      }
+      return paramId;
+    }
+    return convertExpression2(param);
+  });
+  let body;
+  if (expr.body && expr.body.type === "blockStatement") {
+    const statements = expr.body.body.map((stmt) => convertStatement2(stmt));
+    body = t.blockStatement(statements);
+  } else if (expr.body) {
+    body = t.blockStatement([t.returnStatement(convertExpression2(expr.body))]);
+  } else {
+    body = t.blockStatement([]);
+  }
+  currentScope = savedScope;
+  return t.functionExpression(null, params, body);
+}
 function collectOddoIdentifiersOnly(node, names = /* @__PURE__ */ new Set()) {
   if (!node || typeof node !== "object") return Array.from(names);
   if (node.type === "identifier") {
@@ -4812,7 +4822,7 @@ function convertJSXChild2(child) {
     return t.stringLiteral(text);
   } else if (child.type === "jsxExpression") {
     const innerExpr = convertExpression2(child.expression);
-    return createReactiveExpr(innerExpr);
+    return createReactiveExpr(child.expression, innerExpr);
   } else if (child.type === "jsxElement") {
     return convertJSXElement2(child);
   } else if (child.type === "jsxFragment") {
@@ -4829,9 +4839,11 @@ function convertJSXElement2(expr) {
   let propsArg;
   if (hasSpread) {
     const properties = [];
+    const oddoExprs = [];
     for (const attr of expr.attributes) {
       if (attr.type === "jsxSpread") {
         properties.push(t.spreadElement(convertExpression2(attr.expression)));
+        oddoExprs.push(attr.expression);
       } else {
         const key = isValidJSIdentifier(attr.name) ? t.identifier(attr.name) : t.stringLiteral(attr.name);
         let value;
@@ -4841,14 +4853,17 @@ function convertJSXElement2(expr) {
           value = t.stringLiteral(attr.value.value);
         } else if (attr.value.type === "expression") {
           value = convertExpression2(attr.value.value);
+          oddoExprs.push(attr.value.value);
         } else {
           value = convertExpression2(attr.value);
+          oddoExprs.push(attr.value);
         }
         properties.push(t.objectProperty(key, value));
       }
     }
     const propsObj = t.objectExpression(properties);
-    propsArg = createReactiveExpr(propsObj, true);
+    const syntheticOddo = { type: "array", elements: oddoExprs };
+    propsArg = createReactiveExpr(syntheticOddo, propsObj, true);
   } else if (expr.attributes.length === 0) {
     propsArg = t.nullLiteral();
   } else {
@@ -4862,10 +4877,10 @@ function convertJSXElement2(expr) {
         value = t.stringLiteral(attr.value.value);
       } else if (attr.value.type === "expression") {
         const innerExpr = convertExpression2(attr.value.value);
-        value = createReactiveExpr(innerExpr, true);
+        value = createReactiveExpr(attr.value.value, innerExpr, true);
       } else {
         const innerExpr = convertExpression2(attr.value);
-        value = createReactiveExpr(innerExpr, true);
+        value = createReactiveExpr(attr.value, innerExpr, true);
       }
       properties.push(t.objectProperty(key, value));
     }