@oddo/lang 0.0.1 → 0.0.3

package/dist/index.js

@@ -1849,6 +1849,7 @@ var OddoParser = class extends _chevrotain.CstParser {
 var parser = new OddoParser();
 
 // src/ast-converter.mjs
+var sourceText = "";
 function getFirstChild(node, ruleName) {
   var _a;
   const children = (_a = node.children) == null ? void 0 : _a[ruleName];
@@ -2022,8 +2023,11 @@ function convertImportSpecifier(cst) {
     local
   };
 }
-function convertExpression(cst) {
+function convertExpression(cst, source) {
   if (!cst) return null;
+  if (source !== void 0) {
+    sourceText = source;
+  }
   const nodeName = cst.name;
   if (nodeName === "assignment") return convertAssignment(cst);
   if (nodeName === "conditional") return convertConditional(cst);
@@ -2629,8 +2633,10 @@ function convertPostfix(cst) {
   return operand;
 }
 function convertFunctionCall(cst) {
+  var _a;
   let callee = convertExpression(getFirstChild(cst, "memberAccess"));
   const leftParens = cst.children.LeftParen || [];
+  const rightParens = cst.children.RightParen || [];
   const questionDots = cst.children.QuestionDot || [];
   const templateLiterals = cst.children.TemplateLiteral || [];
   if (templateLiterals.length > 0 && leftParens.length === 0) {
@@ -2648,11 +2654,16 @@ function convertFunctionCall(cst) {
   const argLists = getAllChildren(cst, "argumentList");
   const allExprs = getAllChildren(cst, "expression");
   const ops = [
-    ...leftParens.map((t2, i) => ({ k: "c", off: t2.startOffset, i, token: t2 })),
+    ...leftParens.map((t2, i) => ({
+      k: "c",
+      off: t2.startOffset,
+      token: t2,
+      rightParen: rightParens[i]
+    })),
     ...dots.map((t2, i) => ({ k: "d", off: t2.startOffset, i })),
     ...brackets.map((t2, i) => {
-      var _a;
-      return { k: "b", off: t2.startOffset, i, end: (_a = rightBrackets[i]) == null ? void 0 : _a.endOffset };
+      var _a2;
+      return { k: "b", off: t2.startOffset, i, end: (_a2 = rightBrackets[i]) == null ? void 0 : _a2.endOffset };
     }),
     ...questionDots.filter((q) => !leftParens.some((p) => Math.abs(p.startOffset - q.endOffset) <= 1)).map((t2, i) => ({ k: "q", off: t2.startOffset, i }))
   ].sort((a, b) => a.off - b.off);
@@ -2660,7 +2671,12 @@ function convertFunctionCall(cst) {
   for (const op of ops) {
     if (op.k === "c") {
       const isOptional = questionDots.some((q) => q.endOffset < op.token.startOffset && op.token.startOffset - q.endOffset <= 1);
-      const argsCST = argLists[op.i];
+      const leftOff = op.token.startOffset;
+      const rightOff = (_a = op.rightParen) == null ? void 0 : _a.endOffset;
+      const argsCST = argLists.find((al) => {
+        const alStart = getFirstTokenOffset(al);
+        return alStart !== void 0 && alStart > leftOff && (rightOff === void 0 || alStart < rightOff);
+      });
       const args = [];
       if (argsCST) {
         const exprs = getAllChildren(argsCST, "expression");
@@ -2680,9 +2696,9 @@ function convertFunctionCall(cst) {
       if (nextBracket) {
         const bIdx = brackets.indexOf(nextBracket);
         const expr = allExprs.find((e) => {
-          var _a;
+          var _a2;
           const o = getFirstTokenOffset(e);
-          return o > nextBracket.startOffset && o < ((_a = rightBrackets[bIdx]) == null ? void 0 : _a.endOffset);
+          return o > nextBracket.startOffset && o < ((_a2 = rightBrackets[bIdx]) == null ? void 0 : _a2.endOffset);
         });
         if (expr) callee = { type: "memberAccess", object: callee, property: convertExpression(expr), computed: true, optional: true };
         ops.splice(ops.findIndex((o) => o.k === "b" && o.i === bIdx), 1);
@@ -2705,6 +2721,7 @@ function convertMemberAccess(cst) {
   const dots = cst.children.Dot || [];
   const questionDots = cst.children.QuestionDot || [];
   const brackets = cst.children.LeftBracket || [];
+  const rightBrackets = cst.children.RightBracket || [];
   const dotDotDots = cst.children.DotDotDot || [];
   if (dots.length === 0 && questionDots.length === 0 && brackets.length === 0) {
     return object;
@@ -2714,85 +2731,96 @@ function convertMemberAccess(cst) {
     allOps.push({ type: "dot", token: dot, optional: false });
   }
   for (const qDot of questionDots) {
-    allOps.push({ type: "dot", token: qDot, optional: true });
-  }
-  allOps.sort((a, b) => a.token.startOffset - b.token.startOffset);
-  const identifiers = cst.children.Identifier || [];
-  let identifierIndex = 0;
-  for (let i = 0; i < allOps.length; i++) {
-    const op = allOps[i];
-    const identifier2 = identifiers[identifierIndex];
-    if (identifier2) {
-      identifierIndex++;
-      object = {
-        type: "memberAccess",
-        object,
-        property: identifier2.image,
-        computed: false,
-        optional: op.optional
-      };
+    const isFollowedByBracket = brackets.some((b) => b.startOffset > qDot.endOffset && b.startOffset - qDot.endOffset <= 1);
+    if (!isFollowedByBracket) {
+      allOps.push({ type: "dot", token: qDot, optional: true });
     }
   }
-  const expressions = getAllChildren(cst, "expression");
-  let expressionIndex = 0;
   for (let i = 0; i < brackets.length; i++) {
     const bracket = brackets[i];
-    const bracketStart = bracket.startOffset;
-    const isOptional = questionDots.some((qDot) => {
-      return qDot.endOffset < bracketStart && bracketStart - qDot.endOffset <= 1;
-    });
-    const rightBrackets = cst.children.RightBracket || [];
     const rightBracket = rightBrackets[i];
     if (!rightBracket) continue;
+    const isOptional = questionDots.some(
+      (qDot) => qDot.endOffset < bracket.startOffset && bracket.startOffset - qDot.endOffset <= 1
+    );
     const dotDotDotsInRange = dotDotDots.filter(
-      (ddd) => ddd.startOffset > bracketStart && ddd.startOffset < rightBracket.startOffset
+      (ddd) => ddd.startOffset > bracket.startOffset && ddd.startOffset < rightBracket.startOffset
     );
-    if (dotDotDotsInRange.length > 0) {
-      if (expressions.length === expressionIndex) {
-        object = {
-          type: "arraySlice",
-          object,
-          start: null,
-          end: null
-        };
-        continue;
-      }
-      if (expressions.length >= expressionIndex + 2) {
-        const startExpr = expressions[expressionIndex];
-        const endExpr = expressions[expressionIndex + 1];
-        expressionIndex += 2;
+    allOps.push({
+      type: "bracket",
+      token: bracket,
+      rightBracket,
+      optional: isOptional,
+      isSlice: dotDotDotsInRange.length > 0
+    });
+  }
+  allOps.sort((a, b) => a.token.startOffset - b.token.startOffset);
+  const identifiers = cst.children.Identifier || [];
+  const expressions = getAllChildren(cst, "expression");
+  let identifierIndex = 0;
+  let expressionIndex = 0;
+  for (const op of allOps) {
+    if (op.type === "dot") {
+      const identifier2 = identifiers[identifierIndex];
+      if (identifier2) {
+        identifierIndex++;
         object = {
-          type: "arraySlice",
+          type: "memberAccess",
           object,
-          start: convertExpression(startExpr),
-          end: convertExpression(endExpr)
+          property: identifier2.image,
+          computed: false,
+          optional: op.optional
         };
-        continue;
       }
-      if (expressions.length === expressionIndex + 1) {
-        const startExpr = expressions[expressionIndex];
-        expressionIndex++;
-        object = {
-          type: "arraySlice",
-          object,
-          start: convertExpression(startExpr),
-          end: null
-        };
-        continue;
+    } else if (op.type === "bracket") {
+      if (op.isSlice) {
+        const exprsInBracket = expressions.filter((e, idx) => {
+          if (idx < expressionIndex) return false;
+          const exprStart = getFirstTokenOffset(e);
+          return exprStart > op.token.startOffset && exprStart < op.rightBracket.startOffset;
+        });
+        if (exprsInBracket.length === 0) {
+          object = {
+            type: "arraySlice",
+            object,
+            start: null,
+            end: null
+          };
+        } else if (exprsInBracket.length >= 2) {
+          const startExpr = expressions[expressionIndex];
+          const endExpr = expressions[expressionIndex + 1];
+          expressionIndex += 2;
+          object = {
+            type: "arraySlice",
+            object,
+            start: convertExpression(startExpr),
+            end: convertExpression(endExpr)
+          };
+        } else {
+          const startExpr = expressions[expressionIndex];
+          expressionIndex++;
+          object = {
+            type: "arraySlice",
+            object,
+            start: convertExpression(startExpr),
+            end: null
+          };
+        }
+      } else {
+        if (expressions.length > expressionIndex) {
+          const exprCst = expressions[expressionIndex];
+          expressionIndex++;
+          const property = convertExpression(exprCst);
+          object = {
+            type: "memberAccess",
+            object,
+            property,
+            computed: true,
+            optional: op.optional
+          };
+        }
       }
     }
-    if (expressions.length > expressionIndex) {
-      const exprCst = expressions[expressionIndex];
-      expressionIndex++;
-      const property = convertExpression(exprCst);
-      object = {
-        type: "memberAccess",
-        object,
-        property,
-        computed: true,
-        optional: isOptional
-      };
-    }
   }
   return object;
 }
@@ -3282,7 +3310,7 @@ function convertJSXElement(cst) {
   const isSelfClosing = cst.children.JSXSelfClosing && cst.children.JSXSelfClosing.length > 0;
   let children = [];
   if (!isSelfClosing) {
-    children = getAllChildren(cst, "jsxChild").map(convertJSXChild).filter((child) => child !== null);
+    children = convertJSXChildren(getAllChildren(cst, "jsxChild"));
   }
   return {
     type: "jsxElement",
@@ -3295,7 +3323,7 @@ function convertJSXElement(cst) {
 }
 function convertJSXFragment(cst) {
   const childrenCST = getAllChildren(cst, "jsxChild");
-  const children = childrenCST.map(convertJSXChild).filter((child) => child !== null);
+  const children = convertJSXChildren(childrenCST);
   return {
     type: "jsxFragment",
     children
@@ -3420,6 +3448,61 @@ function decodeHTMLEntities(text) {
     }
   });
 }
+function convertJSXChildren(childrenCST) {
+  if (!childrenCST || childrenCST.length === 0) return [];
+  const childrenWithOffsets = childrenCST.map((child) => {
+    const firstOffset = getFirstTokenOffset(child);
+    const lastOffset = getLastTokenOffset(child);
+    return { cst: child, firstOffset, lastOffset };
+  }).filter((c) => c.firstOffset !== void 0);
+  childrenWithOffsets.sort((a, b) => a.firstOffset - b.firstOffset);
+  const result = [];
+  for (let i = 0; i < childrenWithOffsets.length; i++) {
+    const current = childrenWithOffsets[i];
+    if (i > 0 && sourceText) {
+      const prev = childrenWithOffsets[i - 1];
+      const gapStart = prev.lastOffset + 1;
+      const gapEnd = current.firstOffset;
+      if (gapEnd > gapStart) {
+        const gap = sourceText.slice(gapStart, gapEnd);
+        if (gap && /\s/.test(gap)) {
+          result.push({ type: "jsxText", value: " " });
+        }
+      }
+    }
+    const converted = convertJSXChild(current.cst);
+    if (converted !== null) {
+      result.push(converted);
+    }
+  }
+  return result;
+}
+function getLastTokenOffset(node) {
+  if (!node) return void 0;
+  if (node.endOffset !== void 0) {
+    return node.endOffset;
+  }
+  if (node.image !== void 0 && node.startOffset !== void 0) {
+    return node.startOffset + node.image.length - 1;
+  }
+  let lastOffset;
+  if (node.children) {
+    for (const key in node.children) {
+      const children = node.children[key];
+      if (Array.isArray(children)) {
+        for (const child of children) {
+          const childOffset = getLastTokenOffset(child);
+          if (childOffset !== void 0) {
+            if (lastOffset === void 0 || childOffset > lastOffset) {
+              lastOffset = childOffset;
+            }
+          }
+        }
+      }
+    }
+  }
+  return lastOffset;
+}
 function convertJSXChild(cst) {
   if (cst.children.jsxElement) {
     return convertJSXElement(getFirstChild(cst, "jsxElement"));
@@ -3473,8 +3556,9 @@ function convertJSXChild(cst) {
   }
   return null;
 }
-function convertCSTToAST(cst) {
+function convertCSTToAST(cst, source = "") {
   if (!cst) return null;
+  sourceText = source;
   if (cst.name === "program") {
     const statements = getAllChildren(cst, "statement").map(convertStatement);
     return {
@@ -3491,6 +3575,9 @@ var _traverse2 = require('@babel/traverse'); var _traverse3 = _interopRequireDef
 var _types = require('@babel/types'); var t = _interopRequireWildcard(_types);
 var generate = _generator2.default.default || _generator2.default;
 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();
@@ -3891,6 +3978,11 @@ var MODIFIER_TRANSFORMATIONS = {
       const identifiers = bodyIdentifiers.filter((id) => !ownParams.has(id) && isReactive(id));
       const params = identifiers.map((id) => t.identifier(id));
       const deps = identifiers.map((id) => t.identifier(id));
+      const savedScope = currentScope;
+      currentScope = Object.create(currentScope);
+      for (const id of identifiers) {
+        currentScope[id] = { type: "param", reactive: false };
+      }
       let convertedBody;
       if (oddoExpr.body && oddoExpr.body.type === "blockStatement") {
         const statements = oddoExpr.body.body.map((stmt) => convertStatement2(stmt));
@@ -3901,6 +3993,7 @@ var MODIFIER_TRANSFORMATIONS = {
       } else {
         convertedBody = t.blockStatement([]);
       }
+      currentScope = savedScope;
       const arrowFunc = t.arrowFunctionExpression(params, convertedBody);
       wrapDependenciesWithCalls(arrowFunc, identifiers);
       const effectCall = t.callExpression(
@@ -3949,6 +4042,37 @@ function isNonReactive(name) {
   var _a;
   return ((_a = currentScope[name]) == null ? void 0 : _a.reactive) === false;
 }
+function extractBoundNames(pattern, names = []) {
+  var _a, _b;
+  if (!pattern) return names;
+  if (pattern.type === "identifier") {
+    names.push(pattern.name);
+  } else if (pattern.type === "objectPattern") {
+    for (const prop of pattern.properties || []) {
+      if (prop.type === "property") {
+        extractBoundNames(prop.value, names);
+      } else if (prop.type === "restProperty") {
+        if (((_a = prop.argument) == null ? void 0 : _a.type) === "identifier") {
+          names.push(prop.argument.name);
+        }
+      }
+    }
+  } else if (pattern.type === "arrayPattern") {
+    for (const element of pattern.elements || []) {
+      if (!element) continue;
+      if (element.type === "identifier") {
+        names.push(element.name);
+      } else if (element.type === "restElement") {
+        if (((_b = element.argument) == null ? void 0 : _b.type) === "identifier") {
+          names.push(element.argument.name);
+        }
+      } else {
+        extractBoundNames(element, names);
+      }
+    }
+  }
+  return names;
+}
 function generateUniqueId(baseName) {
   let candidate = baseName;
   let i = 2;
@@ -3959,7 +4083,7 @@ function generateUniqueId(baseName) {
   return candidate;
 }
 function collectOddoIdentifiers(node, names = /* @__PURE__ */ new Set()) {
-  var _a, _b, _c;
+  var _a, _b, _c, _d;
   if (!node || typeof node !== "object") return names;
   if (node.type === "program") {
     moduleScope = /* @__PURE__ */ Object.create(null);
@@ -3990,6 +4114,13 @@ function collectOddoIdentifiers(node, names = /* @__PURE__ */ new Set()) {
       for (const param of node.parameters) {
         if (param.name) {
           declareVariable(param.name, "param");
+        } else if (param.type === "destructuringPattern") {
+          const boundNames = extractBoundNames(param.pattern);
+          for (const name of boundNames) {
+            declareVariable(name, "param");
+          }
+        } else if (param.type === "restElement" && ((_d = param.argument) == null ? void 0 : _d.name)) {
+          declareVariable(param.argument.name, "param");
         }
       }
     }
@@ -4149,9 +4280,17 @@ function convertExpressionStatement2(stmt) {
           let leftExpr = null;
           if (blockStmt.expression.type === "variableDeclaration" || blockStmt.expression.type === "assignment") {
             leftExpr = convertExpression2(blockStmt.expression.left);
-            valueExpr = convertExpression2(blockStmt.expression.right);
+            if (stmt.modifier === "mutate" || stmt.modifier === "effect") {
+              valueExpr = blockStmt.expression.right;
+            } else {
+              valueExpr = convertExpression2(blockStmt.expression.right);
+            }
           } else {
-            valueExpr = convertExpression2(blockStmt.expression);
+            if (stmt.modifier === "mutate" || stmt.modifier === "effect") {
+              valueExpr = blockStmt.expression;
+            } else {
+              valueExpr = convertExpression2(blockStmt.expression);
+            }
           }
           const { transform } = modifierTransform;
           usedModifiers.add(stmt.modifier);
@@ -4616,7 +4755,7 @@ function convertObjectPattern(expr) {
 function convertJSXChild2(child) {
   if (child.type === "jsxText") {
     const text = child.value;
-    if (!text.trim()) return null;
+    if (!text) return null;
     return t.stringLiteral(text);
   } else if (child.type === "jsxExpression") {
     const innerExpr = convertExpression2(child.expression);
@@ -4641,7 +4780,7 @@ function convertJSXElement2(expr) {
       if (attr.type === "jsxSpread") {
         properties.push(t.spreadElement(convertExpression2(attr.expression)));
       } else {
-        const key = t.identifier(attr.name);
+        const key = isValidJSIdentifier(attr.name) ? t.identifier(attr.name) : t.stringLiteral(attr.name);
         let value;
         if (attr.value === null) {
           value = t.booleanLiteral(true);
@@ -4662,7 +4801,7 @@ function convertJSXElement2(expr) {
   } else {
     const properties = [];
     for (const attr of expr.attributes) {
-      const key = t.identifier(attr.name);
+      const key = isValidJSIdentifier(attr.name) ? t.identifier(attr.name) : t.stringLiteral(attr.name);
       let value;
       if (attr.value === null) {
         value = t.booleanLiteral(true);
@@ -4917,7 +5056,7 @@ function parseOddo(input) {
     });
     throw new Error(`Parser errors: ${JSON.stringify(errors)}`);
   }
-  const ast = convertCSTToAST(cst);
+  const ast = convertCSTToAST(cst, input);
   return ast;
 }
 function parseOddoExpression(input) {
@@ -4944,7 +5083,7 @@ function parseOddoExpression(input) {
     });
     throw new Error(`Parser errors: ${JSON.stringify(errors)}`);
   }
-  const ast = convertExpression(cst);
+  const ast = convertExpression(cst, input);
   return ast;
 }
 function compileOddoToJS(input, config = {}) {