@oddo/lang 0.0.7 → 0.0.9

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,15 @@ 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 savedScope = currentScope;
+      currentScope = Object.create(currentScope);
+      currentScope[reactiveScope] = false;
+      const valueExpr = convertExpression2(oddoExpr);
+      currentScope = savedScope;
       const params = identifiers.map((id) => t.identifier(id));
       const deps = identifiers.map((id) => t.identifier(id));
       const arrowFunc = t.arrowFunctionExpression(params, valueExpr);
@@ -3808,28 +3749,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 }
@@ -3896,6 +3815,9 @@ var MODIFIER_TRANSFORMATIONS = {
         ...stateContainerNames,
         ...outerDepsArray.filter((id) => !mutableVariables.has(id))
       ]);
+      const savedScopeMutate = currentScope;
+      currentScope = Object.create(currentScope);
+      currentScope[reactiveScope] = false;
       for (const assignment of assignments) {
         const rightBabel = convertExpression2(assignment.rightOddo);
         const tempFile = t.file(t.program([t.expressionStatement(rightBabel)]));
@@ -3948,6 +3870,7 @@ var MODIFIER_TRANSFORMATIONS = {
           );
         }
       }
+      currentScope = savedScopeMutate;
       if (stateContainerNames.length > 0) {
         mutateBodyStmts.push(
           t.expressionStatement(
@@ -4001,6 +3924,7 @@ var MODIFIER_TRANSFORMATIONS = {
       const deps = identifiers.map((id) => t.identifier(id));
       const savedScope = currentScope;
       currentScope = Object.create(currentScope);
+      currentScope[reactiveScope] = false;
       for (const id of identifiers) {
         currentScope[id] = { type: "param", reactive: false };
       }
@@ -4028,16 +3952,61 @@ 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 reactiveDeps = getReactiveDeps(identifiers);
+        const savedScope = currentScope;
+        if (reactiveDeps.length > 0) {
+          currentScope = Object.create(currentScope);
+          currentScope[reactiveScope] = false;
+        }
+        const valueExpr = convertExpression2(oddoExpr);
+        if (reactiveDeps.length > 0) {
+          currentScope = savedScope;
+        }
         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);
     }
   }
 };
@@ -4048,6 +4017,7 @@ var stateSetterMap = /* @__PURE__ */ new Map();
 var mutableVariables = /* @__PURE__ */ new Set();
 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";
   currentScope[name] = { type, reactive };
@@ -4108,6 +4078,7 @@ function collectOddoIdentifiers(node, names = /* @__PURE__ */ new Set()) {
   if (!node || typeof node !== "object") return names;
   if (node.type === "program") {
     moduleScope = /* @__PURE__ */ Object.create(null);
+    moduleScope[reactiveScope] = true;
     currentScope = moduleScope;
   }
   if (node.type === "identifier") {
@@ -4197,7 +4168,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 +4268,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 +4295,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 +4320,27 @@ 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;
+    let finalExpr;
+    if (oddoRight.type !== "arrowFunction") {
+      const identifiers = collectOddoIdentifiersOnly(oddoRight);
+      const reactiveDeps = getReactiveDeps(identifiers);
+      const savedScope = currentScope;
+      if (reactiveDeps.length > 0) {
+        currentScope = Object.create(currentScope);
+        currentScope[reactiveScope] = false;
+      }
+      const right = convertExpression2(oddoRight);
+      if (reactiveDeps.length > 0) {
+        currentScope = savedScope;
+      }
+      const liftedExpr = createLiftedExpr(right, identifiers);
+      finalExpr = liftedExpr || right;
+    } else {
+      finalExpr = convertExpression2(oddoRight);
+    }
     return t.variableDeclaration("const", [
-      t.variableDeclarator(left, liftedExpr || right)
+      t.variableDeclarator(left, finalExpr)
     ]);
   }
   let expression = null;
@@ -4499,17 +4486,21 @@ function convertArrowFunction2(expr) {
   if (expr._scope) {
     currentScope = expr._scope;
   }
+  const inReactiveScope = (savedScope == null ? void 0 : savedScope[reactiveScope]) !== false;
   const bodyIdentifiers = collectOddoIdentifiersOnly(expr.body);
-  const reactiveDepsForBody = bodyIdentifiers.filter((id) => {
+  const reactiveDepsForBody = inReactiveScope ? bodyIdentifiers.filter((id) => {
     var _a;
     const isOwnParam = (_a = expr.parameters) == null ? void 0 : _a.some((p) => p.name === id);
     if (isOwnParam) return false;
     const varInfo = savedScope == null ? void 0 : savedScope[id];
     return (varInfo == null ? void 0 : varInfo.reactive) === true;
-  });
+  }) : [];
   for (const dep of reactiveDepsForBody) {
     currentScope[dep] = { type: "param", reactive: false };
   }
+  if (reactiveDepsForBody.length > 0) {
+    currentScope[reactiveScope] = false;
+  }
   const params = expr.parameters.map((param) => {
     if (param.type === "restElement") {
       return t.restElement(convertExpression2(param.argument));
@@ -4540,7 +4531,7 @@ function convertArrowFunction2(expr) {
     body = null;
   }
   currentScope = savedScope;
-  if (reactiveDepsForBody.length > 0 || params.length > 0) {
+  if (reactiveDepsForBody.length > 0 || params.length > 0 && inReactiveScope) {
     usedModifiers.add("liftFn");
     const depParams = reactiveDepsForBody.map((id) => t.identifier(id));
     const allParams = [...depParams, ...params];
@@ -4553,6 +4544,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") {
@@ -4811,8 +4854,12 @@ function convertJSXChild2(child) {
     if (!text) return null;
     return t.stringLiteral(text);
   } else if (child.type === "jsxExpression") {
+    const savedScope = currentScope;
+    currentScope = Object.create(currentScope);
+    currentScope[reactiveScope] = false;
     const innerExpr = convertExpression2(child.expression);
-    return createReactiveExpr(innerExpr);
+    currentScope = savedScope;
+    return createReactiveExpr(child.expression, innerExpr);
   } else if (child.type === "jsxElement") {
     return convertJSXElement2(child);
   } else if (child.type === "jsxFragment") {
@@ -4828,10 +4875,15 @@ function convertJSXElement2(expr) {
   const hasSpread = expr.attributes.some((attr) => attr.type === "jsxSpread");
   let propsArg;
   if (hasSpread) {
+    const savedScopeSpread = currentScope;
+    currentScope = Object.create(currentScope);
+    currentScope[reactiveScope] = false;
     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 +4893,18 @@ 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));
       }
     }
+    currentScope = savedScopeSpread;
     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 {
@@ -4861,11 +4917,19 @@ function convertJSXElement2(expr) {
       } else if (attr.value.type === "string") {
         value = t.stringLiteral(attr.value.value);
       } else if (attr.value.type === "expression") {
+        const savedScopeAttr = currentScope;
+        currentScope = Object.create(currentScope);
+        currentScope[reactiveScope] = false;
         const innerExpr = convertExpression2(attr.value.value);
-        value = createReactiveExpr(innerExpr, true);
+        currentScope = savedScopeAttr;
+        value = createReactiveExpr(attr.value.value, innerExpr, true);
       } else {
+        const savedScopeAttr = currentScope;
+        currentScope = Object.create(currentScope);
+        currentScope[reactiveScope] = false;
         const innerExpr = convertExpression2(attr.value);
-        value = createReactiveExpr(innerExpr, true);
+        currentScope = savedScopeAttr;
+        value = createReactiveExpr(attr.value, innerExpr, true);
       }
       properties.push(t.objectProperty(key, value));
     }