@oddo/lang 0.0.9 → 0.0.11

package/dist/index.js

@@ -3586,7 +3586,7 @@ var traverse = _traverse3.default.default || _traverse3.default;
 function isValidJSIdentifier(name) {
   return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
-function wrapDependenciesWithCalls(arrowFunc, deps) {
+function wrapDependenciesWithCalls(arrowFunc, deps, prefix = "") {
   const depSet = new Set(deps);
   const locals = /* @__PURE__ */ new Set();
   const tempFile = t.file(t.program([t.expressionStatement(arrowFunc)]));
@@ -3602,6 +3602,14 @@ function wrapDependenciesWithCalls(arrowFunc, deps) {
   const shorthandToExpand = [];
   traverse(tempFile, {
     noScope: true,
+    // Skip already-processed reactive expression calls - don't modify their deps arrays
+    // These have the pattern: _x(fn, deps) or _computed(fn, deps) or similar
+    CallExpression(path) {
+      const callee = path.node.callee;
+      if (t.isIdentifier(callee) && callee.name.startsWith("_") && path.node.arguments.length === 2 && t.isArrowFunctionExpression(path.node.arguments[0]) && t.isArrayExpression(path.node.arguments[1])) {
+        path.skip();
+      }
+    },
     Identifier(path) {
       var _a;
       if (t.isArrowFunctionExpression(path.parent) && path.parent.params.includes(path.node)) {
@@ -3631,9 +3639,9 @@ function wrapDependenciesWithCalls(arrowFunc, deps) {
   });
   shorthandToExpand.forEach(({ prop, name }) => {
     prop.shorthand = false;
-    prop.value = t.callExpression(t.identifier(name), []);
+    prop.value = t.callExpression(t.identifier(prefix + name), []);
   });
-  toReplace.forEach((p) => p.replaceWith(t.callExpression(t.identifier(p.node.name), [])));
+  toReplace.forEach((p) => p.replaceWith(t.callExpression(t.identifier(prefix + p.node.name), [])));
 }
 function getReactiveDeps(identifiers) {
   return identifiers.filter((id) => {
@@ -3670,7 +3678,7 @@ function createLiftedExpr(valueExpr, identifiers) {
   );
 }
 function createReactiveExpr(oddoExpr, valueExpr, attrExpression = false) {
-  const allIdentifiers = collectOddoIdentifiersOnly(oddoExpr);
+  const allIdentifiers = collectOddoIdentifiersOnly(oddoExpr, /* @__PURE__ */ new Set(), true);
   const identifiers = allIdentifiers.filter((id) => isReactive(id));
   const pragma = attrExpression ? "computed" : "x";
   if (identifiers.length === 0) {
@@ -3685,10 +3693,10 @@ function createReactiveExpr(oddoExpr, valueExpr, attrExpression = false) {
     );
   }
   usedModifiers.add(pragma);
-  const params = identifiers.map((id) => t.identifier(id));
+  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);
+  wrapDependenciesWithCalls(arrowFunc, identifiers, "_");
   return t.callExpression(
     t.identifier(modifierAliases[pragma]),
     [arrowFunc, t.arrayExpression(deps)]
@@ -3698,10 +3706,29 @@ var MODIFIER_TRANSFORMATIONS = {
   state: {
     needsImport: true,
     // @state x = 3 -> const [x, setX] = _state(3);
-    transform: (valueExpr, leftExpr) => {
+    // @state x = reactiveVar -> const [x, setX] = _state(_lift(_reactiveVar => _reactiveVar(), [reactiveVar]));
+    // Receives Oddo AST, extracts deps, lifts if needed
+    transform: (oddoExpr, leftExpr) => {
+      const allIdentifiers = collectOddoIdentifiersOnly(oddoExpr);
+      const reactiveDeps = allIdentifiers.filter((id) => isReactive(id));
+      const convertedExpr = convertExpression2(oddoExpr);
+      let stateArg;
+      if (reactiveDeps.length > 0) {
+        usedModifiers.add("lift");
+        const prefixedParams = reactiveDeps.map((id) => t.identifier("_" + id));
+        const deps = reactiveDeps.map((id) => t.identifier(id));
+        const arrowFunc = t.arrowFunctionExpression(prefixedParams, convertedExpr);
+        wrapDependenciesWithCalls(arrowFunc, reactiveDeps, "_");
+        stateArg = t.callExpression(
+          t.identifier(modifierAliases["lift"]),
+          [arrowFunc, t.arrayExpression(deps)]
+        );
+      } else {
+        stateArg = convertedExpr;
+      }
       const stateCall = t.callExpression(
         t.identifier(modifierAliases["state"]),
-        [valueExpr]
+        [stateArg]
       );
       if (leftExpr && t.isIdentifier(leftExpr)) {
         const getterName = leftExpr.name;
@@ -3717,6 +3744,19 @@ var MODIFIER_TRANSFORMATIONS = {
             stateCall
           )
         ]);
+      } else if (leftExpr && t.isArrayPattern(leftExpr) && leftExpr.elements.length === 2) {
+        const getterName = leftExpr.elements[0].name;
+        const setterName = leftExpr.elements[1].name;
+        stateSetterMap.set(getterName, setterName);
+        return t.variableDeclaration("const", [
+          t.variableDeclarator(
+            t.arrayPattern([
+              t.identifier(getterName),
+              t.identifier(setterName)
+            ]),
+            stateCall
+          )
+        ]);
       }
       return t.expressionStatement(stateCall);
     }
@@ -4019,7 +4059,7 @@ var moduleScope = null;
 var currentScope = null;
 var reactiveScope = /* @__PURE__ */ Symbol("reactive-scope");
 function declareVariable(name, type) {
-  const reactive = type === "state" || type === "computed" || type === "param" || type === "import-oddo";
+  const reactive = type === "state" || type === "computed" || type === "reactive-param" || type === "import-oddo";
   currentScope[name] = { type, reactive };
 }
 function isDeclared(name) {
@@ -4074,7 +4114,7 @@ function generateUniqueId(baseName) {
   return candidate;
 }
 function collectOddoIdentifiers(node, names = /* @__PURE__ */ new Set()) {
-  var _a, _b, _c, _d;
+  var _a, _b, _c, _d, _e, _f;
   if (!node || typeof node !== "object") return names;
   if (node.type === "program") {
     moduleScope = /* @__PURE__ */ Object.create(null);
@@ -4085,15 +4125,21 @@ function collectOddoIdentifiers(node, names = /* @__PURE__ */ new Set()) {
     names.add(node.name);
   }
   if (node.type === "expressionStatement") {
-    const varName = (_b = (_a = node.expression) == null ? void 0 : _a.left) == null ? void 0 : _b.name;
-    if (varName) {
+    const left = (_a = node.expression) == null ? void 0 : _a.left;
+    const varName = left == null ? void 0 : left.name;
+    if (node.modifier === "state" && (left == null ? void 0 : left.type) === "arrayPattern" && ((_b = left.elements) == null ? void 0 : _b.length) === 2) {
+      const getterName = (_c = left.elements[0]) == null ? void 0 : _c.name;
+      const setterName = (_d = left.elements[1]) == null ? void 0 : _d.name;
+      if (getterName) declareVariable(getterName, "state");
+      if (setterName) declareVariable(setterName, "immutable");
+    } else if (varName) {
       if (node.modifier === "state") {
         declareVariable(varName, "state");
       } else if (node.modifier === "computed") {
         declareVariable(varName, "computed");
       } else if (node.modifier === "mutable") {
         declareVariable(varName, "mutable");
-      } else if (!node.modifier && ((_c = node.expression) == null ? void 0 : _c.type) === "variableDeclaration") {
+      } else if (!node.modifier && ((_e = node.expression) == null ? void 0 : _e.type) === "variableDeclaration") {
         declareVariable(varName, "immutable");
       }
     }
@@ -4125,7 +4171,7 @@ function collectOddoIdentifiers(node, names = /* @__PURE__ */ new Set()) {
           for (const name of boundNames) {
             declareVariable(name, "param");
           }
-        } else if (param.type === "restElement" && ((_d = param.argument) == null ? void 0 : _d.name)) {
+        } else if (param.type === "restElement" && ((_f = param.argument) == null ? void 0 : _f.name)) {
           declareVariable(param.argument.name, "param");
         }
       }
@@ -4268,13 +4314,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" || stmt.modifier === "computed" || stmt.modifier === "mutable" || stmt.modifier === "component" || stmt.modifier === "hook") {
+        if (stmt.modifier === "mutate" || stmt.modifier === "effect" || stmt.modifier === "computed" || stmt.modifier === "mutable" || stmt.modifier === "component" || stmt.modifier === "hook" || stmt.modifier === "state") {
           valueExpr = stmt.expression.right;
         } else {
           valueExpr = convertExpression2(stmt.expression.right);
         }
       } else {
-        if (stmt.modifier === "mutate" || stmt.modifier === "effect" || stmt.modifier === "computed" || stmt.modifier === "mutable" || stmt.modifier === "component" || stmt.modifier === "hook") {
+        if (stmt.modifier === "mutate" || stmt.modifier === "effect" || stmt.modifier === "computed" || stmt.modifier === "mutable" || stmt.modifier === "component" || stmt.modifier === "hook" || stmt.modifier === "state") {
           valueExpr = stmt.expression;
         } else {
           valueExpr = convertExpression2(stmt.expression);
@@ -4295,13 +4341,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" || stmt.modifier === "computed" || stmt.modifier === "mutable" || stmt.modifier === "component" || stmt.modifier === "hook") {
+            if (stmt.modifier === "mutate" || stmt.modifier === "effect" || stmt.modifier === "computed" || stmt.modifier === "mutable" || stmt.modifier === "component" || stmt.modifier === "hook" || stmt.modifier === "state") {
               valueExpr = blockStmt.expression.right;
             } else {
               valueExpr = convertExpression2(blockStmt.expression.right);
             }
           } else {
-            if (stmt.modifier === "mutate" || stmt.modifier === "effect" || stmt.modifier === "computed" || stmt.modifier === "mutable" || stmt.modifier === "component" || stmt.modifier === "hook") {
+            if (stmt.modifier === "mutate" || stmt.modifier === "effect" || stmt.modifier === "computed" || stmt.modifier === "mutable" || stmt.modifier === "component" || stmt.modifier === "hook" || stmt.modifier === "state") {
               valueExpr = blockStmt.expression;
             } else {
               valueExpr = convertExpression2(blockStmt.expression);
@@ -4345,7 +4391,31 @@ function convertExpressionStatement2(stmt) {
   }
   let expression = null;
   if (stmt.expression) {
-    expression = convertExpression2(stmt.expression);
+    const isPlainExpr = stmt.expression.type !== "variableDeclaration" && stmt.expression.type !== "assignment" && stmt.expression.type !== "arraySliceAssignment";
+    if (isPlainExpr) {
+      const allIdentifiers = collectOddoIdentifiersOnly(stmt.expression);
+      const reactiveDeps = allIdentifiers.filter((id) => isReactive(id));
+      if (reactiveDeps.length > 0) {
+        const savedScope = currentScope;
+        currentScope = Object.create(currentScope);
+        currentScope[reactiveScope] = false;
+        const convertedExpr = convertExpression2(stmt.expression);
+        currentScope = savedScope;
+        usedModifiers.add("lift");
+        const prefixedParams = reactiveDeps.map((id) => t.identifier("_" + id));
+        const deps = reactiveDeps.map((id) => t.identifier(id));
+        const arrowFunc = t.arrowFunctionExpression(prefixedParams, convertedExpr);
+        wrapDependenciesWithCalls(arrowFunc, reactiveDeps, "_");
+        expression = t.callExpression(
+          t.identifier(modifierAliases["lift"]),
+          [arrowFunc, t.arrayExpression(deps)]
+        );
+      } else {
+        expression = convertExpression2(stmt.expression);
+      }
+    } else {
+      expression = convertExpression2(stmt.expression);
+    }
   }
   if (stmt.block) {
     const block = convertBlockStatement(stmt.block);
@@ -4596,17 +4666,20 @@ function convertReactiveContainer(expr) {
   currentScope = savedScope;
   return t.functionExpression(null, params, body);
 }
-function collectOddoIdentifiersOnly(node, names = /* @__PURE__ */ new Set()) {
+function collectOddoIdentifiersOnly(node, names = /* @__PURE__ */ new Set(), stopAtJsxExpressions = false) {
   if (!node || typeof node !== "object") return Array.from(names);
+  if (stopAtJsxExpressions && node.type === "jsxExpression") {
+    return Array.from(names);
+  }
   if (node.type === "identifier") {
     names.add(node.name);
   }
   if (node.type === "property") {
     if (node.computed && node.key) {
-      collectOddoIdentifiersOnly(node.key, names);
+      collectOddoIdentifiersOnly(node.key, names, stopAtJsxExpressions);
     }
     if (node.value) {
-      collectOddoIdentifiersOnly(node.value, names);
+      collectOddoIdentifiersOnly(node.value, names, stopAtJsxExpressions);
     }
     return Array.from(names);
   }
@@ -4614,9 +4687,9 @@ function collectOddoIdentifiersOnly(node, names = /* @__PURE__ */ new Set()) {
     if (key === "type") continue;
     const val = node[key];
     if (Array.isArray(val)) {
-      val.forEach((item) => collectOddoIdentifiersOnly(item, names));
+      val.forEach((item) => collectOddoIdentifiersOnly(item, names, stopAtJsxExpressions));
     } else if (val && typeof val === "object") {
-      collectOddoIdentifiersOnly(val, names);
+      collectOddoIdentifiersOnly(val, names, stopAtJsxExpressions);
     }
   }
   return Array.from(names);