@danielx/civet 0.6.34 → 0.6.36

package/dist/main.mjs

@@ -523,23 +523,16 @@ var require_lib = __commonJS({
       }
     }
     function addPostfixStatement(statement, ws, post) {
-      let children, expressions;
-      const prefix = post.blockPrefix || post.condition?.expression.blockPrefix;
-      if (prefix?.length) {
-        const indent = prefix[0][0];
-        expressions = [...prefix, [indent, statement]];
-        children = [" {\n", ...expressions, "\n", indent?.slice?.(0, -2), "}"];
-      } else {
-        expressions = [["", statement]];
-        children = [" { ", ...expressions, " }"];
-      }
+      const expressions = [
+        ...post.blockPrefix || [],
+        ["", statement]
+      ];
       const block = {
         type: "BlockStatement",
-        children,
+        children: [" { ", expressions, " }"],
         expressions
       };
-      children = [...post.children];
-      children.push(block);
+      const children = [...post.children, block];
       if (!isWhitespaceOrEmpty(ws))
         children.push(ws);
       post = { ...post, children, block };
@@ -1980,6 +1973,66 @@ var require_lib = __commonJS({
       }
       return parts;
     }
+    function duplicateBlock(block) {
+      const expressions = [...block.expressions];
+      const children = [...block.children];
+      children.splice(children.indexOf(block.expressions), 1, expressions);
+      return {
+        ...block,
+        expressions,
+        children
+      };
+    }
+    function makeGetterMethod(name, ws, value, block, kind = { token: "get" }, autoReturn = true) {
+      const { token } = kind;
+      ws = insertTrimmingSpace(ws, "");
+      let setVal;
+      const parameters = token === "get" ? {
+        type: "Parameters",
+        children: ["()"],
+        names: [],
+        implicit: true
+      } : {
+        type: "Parameters",
+        children: ["(", setVal = makeRef("value"), ")"],
+        names: [],
+        implicit: false
+      };
+      let expressions;
+      if (block) {
+        block = duplicateBlock(block);
+        expressions = block.expressions;
+      } else {
+        expressions = [];
+        block = {
+          type: "BlockStatement",
+          expressions,
+          children: ["{ ", expressions, " }"]
+        };
+      }
+      if (autoReturn) {
+        const finalStatement = token === "get" ? [[expressions[0]?.[0] || "", ws], wrapWithReturn(value)] : [[expressions[0]?.[0] || "", ws], [value, " = ", setVal]];
+        expressions.push(finalStatement);
+      }
+      const children = [kind, " ", name, parameters, block];
+      return {
+        type: "MethodDefinition",
+        children,
+        name,
+        signature: {
+          type: "MethodSignature",
+          modifier: {
+            get: token === "get",
+            set: token === "set",
+            async: false
+          },
+          name,
+          returnType: void 0
+        },
+        block,
+        parameters
+      };
+    }
     function needsRef(expression, base = "ref") {
       switch (expression.type) {
         case "Ref":
@@ -2055,6 +2108,81 @@ var require_lib = __commonJS({
         children
       };
     }
+    function processDeclarationCondition(condition) {
+      if (!(condition.type === "DeclarationCondition")) {
+        return;
+      }
+      const ref = makeRef();
+      const { decl, bindings } = condition.declaration;
+      const binding = bindings[0];
+      const { pattern, suffix, initializer, splices, thisAssignments } = binding;
+      const initCondition = {
+        type: "AssignmentExpression",
+        children: [ref, initializer],
+        hoistDec: {
+          type: "Declaration",
+          children: ["let ", ref, suffix],
+          names: []
+        },
+        blockPrefix: [
+          ["", [decl, pattern, suffix, " = ", ref, ...splices], ";"],
+          ...thisAssignments
+        ],
+        pattern,
+        ref
+      };
+      Object.assign(condition, initCondition);
+    }
+    function processDeclarationConditions(node) {
+      gatherRecursiveAll(node, (n) => {
+        return n.type === "IfStatement" || n.type === "IterationStatement";
+      }).forEach(processDeclarationConditionStatement);
+    }
+    function processDeclarationConditionStatement(s) {
+      const { condition } = s;
+      if (!condition) {
+        return;
+      }
+      processDeclarationCondition(condition.expression);
+      const { ref, pattern } = condition.expression;
+      if (pattern) {
+        let conditions = [];
+        getPatternConditions(pattern, ref, conditions);
+        conditions = conditions.filter((c) => {
+          return !(c.length === 3 && c[0] === "typeof " && c[1] === ref && c[2] === " === 'object'") && !(c.length === 2 && c[0] === ref && c[1] === " != null");
+        });
+        if (conditions.length) {
+          condition.children.unshift("(");
+          conditions.forEach(function(c) {
+            return condition.children.push(" && ", c);
+          });
+          condition.children.push(")");
+        }
+      }
+      switch (s.type) {
+        case "IfStatement": {
+          const { else: e } = s;
+          const block = blockWithPrefix(condition.expression.blockPrefix, s.then);
+          s.then = block;
+          const toAdd = [block];
+          if (block.bare && e) {
+            toAdd.push(";");
+          }
+          s.children.splice(2, 1, ...toAdd);
+          updateParentPointers(block, s);
+          break;
+        }
+        case "IterationStatement": {
+          const { children, block } = s;
+          const newBlock = blockWithPrefix(condition.expression.blockPrefix, block);
+          s.children = children.map(function(c) {
+            return c.type === "BlockStatement" ? newBlock : c;
+          });
+          updateParentPointers(newBlock, s);
+          break;
+        }
+      }
+    }
     function implicitFunctionBlock(f) {
       if (f.abstract || f.block || f.signature?.optional)
         return;
@@ -2728,6 +2856,7 @@ var require_lib = __commonJS({
       assert.equal(m.JSXTagStack.length, 1, "JSXTagStack");
       addParentPointers(root);
       const { expressions: statements } = root;
+      processDeclarationConditions(statements);
       processPipelineExpressions(statements);
       processAssignments(statements);
       processPatternMatching(statements, ReservedWord);
@@ -3278,6 +3407,7 @@ var require_lib = __commonJS({
       literalValue,
       makeAsConst,
       makeEmptyBlock,
+      makeGetterMethod,
       makeLeftHandSideExpression,
       makeRef,
       maybeRef,
@@ -3373,6 +3503,9 @@ var require_parser = __commonJS({
       RHS,
       ParenthesizedAssignment,
       UnaryExpression,
+      UnaryWithoutParenthesizedAssignment,
+      UnaryBody,
+      UnaryWithoutParenthesizedAssignmentBody,
       UnaryPostfix,
       UpdateExpression,
       UpdateExpressionSymbol,
@@ -3429,6 +3562,7 @@ var require_parser = __commonJS({
       OptionalDot,
       NonNullAssertion,
       MemberExpression,
+      MemberBase,
       MemberExpressionRest,
       MemberExpressionRestBody,
       MemberBracketContent,
@@ -4647,7 +4781,7 @@ var require_parser = __commonJS({
     function ParenthesizedAssignment(ctx, state) {
       return $EVENT(ctx, state, "ParenthesizedAssignment", ParenthesizedAssignment$0);
     }
-    var UnaryExpression$0 = $TS($S($Q(UnaryOp), $C(UpdateExpression, NestedNonAssignmentExtendedExpression), $E(UnaryPostfix)), function($skip, $loc, $0, $1, $2, $3) {
+    var UnaryExpression$0 = $TS($S($Q(UnaryOp), UnaryBody, $E(UnaryPostfix)), function($skip, $loc, $0, $1, $2, $3) {
       var pre = $1;
       var exp = $2;
       var post = $3;
@@ -4663,6 +4797,30 @@ var require_parser = __commonJS({
     function UnaryExpression(ctx, state) {
       return $EVENT_C(ctx, state, "UnaryExpression", UnaryExpression$$);
     }
+    var UnaryWithoutParenthesizedAssignment$0 = $TS($S($Q(UnaryOp), UnaryWithoutParenthesizedAssignmentBody, $E(UnaryPostfix)), function($skip, $loc, $0, $1, $2, $3) {
+      var pre = $1;
+      var exp = $2;
+      var post = $3;
+      return processUnaryExpression(pre, exp, post);
+    });
+    function UnaryWithoutParenthesizedAssignment(ctx, state) {
+      return $EVENT(ctx, state, "UnaryWithoutParenthesizedAssignment", UnaryWithoutParenthesizedAssignment$0);
+    }
+    var UnaryBody$0 = ParenthesizedAssignment;
+    var UnaryBody$1 = UpdateExpression;
+    var UnaryBody$2 = ExpressionizedStatementWithTrailingCallExpressions;
+    var UnaryBody$3 = NestedNonAssignmentExtendedExpression;
+    var UnaryBody$$ = [UnaryBody$0, UnaryBody$1, UnaryBody$2, UnaryBody$3];
+    function UnaryBody(ctx, state) {
+      return $EVENT_C(ctx, state, "UnaryBody", UnaryBody$$);
+    }
+    var UnaryWithoutParenthesizedAssignmentBody$0 = UpdateExpression;
+    var UnaryWithoutParenthesizedAssignmentBody$1 = ExpressionizedStatementWithTrailingCallExpressions;
+    var UnaryWithoutParenthesizedAssignmentBody$2 = NestedNonAssignmentExtendedExpression;
+    var UnaryWithoutParenthesizedAssignmentBody$$ = [UnaryWithoutParenthesizedAssignmentBody$0, UnaryWithoutParenthesizedAssignmentBody$1, UnaryWithoutParenthesizedAssignmentBody$2];
+    function UnaryWithoutParenthesizedAssignmentBody(ctx, state) {
+      return $EVENT_C(ctx, state, "UnaryWithoutParenthesizedAssignmentBody", UnaryWithoutParenthesizedAssignmentBody$$);
+    }
     var UnaryPostfix$0 = QuestionMark;
     var UnaryPostfix$1 = $T($P($S(__, $C(As, Satisfies), Type)), function(value) {
       return { "ts": true, "children": value };
@@ -4671,7 +4829,7 @@ var require_parser = __commonJS({
     function UnaryPostfix(ctx, state) {
       return $EVENT_C(ctx, state, "UnaryPostfix", UnaryPostfix$$);
     }
-    var UpdateExpression$0 = $TS($S(UpdateExpressionSymbol, UnaryExpression), function($skip, $loc, $0, $1, $2) {
+    var UpdateExpression$0 = $TS($S(UpdateExpressionSymbol, UnaryWithoutParenthesizedAssignment), function($skip, $loc, $0, $1, $2) {
       return {
         type: "UpdateExpression",
         assigned: $2,
@@ -5064,10 +5222,22 @@ var require_parser = __commonJS({
       return $EVENT(ctx, state, "NestedClassElement", NestedClassElement$0);
     }
     var ClassElement$0 = $TS($S($E(Decorators), $E(AccessModifier), $E($S(Static, $E(_))), ClassElementDefinition), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var decorators = $1;
       var definition = $4;
+      if (definition.type === "ShorthandMethodDefinition") {
+        return {
+          ...definition,
+          children: definition.children.map((c) => {
+            return {
+              ...c,
+              children: [decorators, ...c.children]
+            };
+          })
+        };
+      }
       return {
         ...definition,
-        children: [$1, $2, $3, ...definition.children]
+        children: [decorators, $2, $3, ...definition.children]
       };
     });
     var ClassElement$1 = $TS($S(Static, BracedBlock), function($skip, $loc, $0, $1, $2) {
@@ -5177,7 +5347,14 @@ var require_parser = __commonJS({
     var ThisLiteral$1 = $TS($S(AtThis, $TEXT($S($E(Hash), IdentifierName))), function($skip, $loc, $0, $1, $2) {
       var at = $1;
       var id = $2;
-      return [at, ".", id];
+      return {
+        type: "MemberExpression",
+        children: [at, {
+          type: "PropertyAccess",
+          name: id,
+          children: [".", id]
+        }]
+      };
     });
     var ThisLiteral$2 = AtThis;
     var ThisLiteral$3 = PrivateThis;
@@ -5191,7 +5368,14 @@ var require_parser = __commonJS({
     });
     var PrivateThis$1 = $TV(PrivateIdentifier, function($skip, $loc, $0, $1) {
       var id = $0;
-      return ["this.", id];
+      return {
+        type: "MemberExpression",
+        children: ["this", {
+          type: "PropertyAccess",
+          name: id.name,
+          children: [".", id]
+        }]
+      };
     });
     var PrivateThis$$ = [PrivateThis$0, PrivateThis$1];
     function PrivateThis(ctx, state) {
@@ -5278,7 +5462,7 @@ var require_parser = __commonJS({
     function NonNullAssertion(ctx, state) {
       return $EVENT(ctx, state, "NonNullAssertion", NonNullAssertion$0);
     }
-    var MemberExpression$0 = $TS($S($C(PrimaryExpression, SuperProperty, MetaProperty), $Q(MemberExpressionRest)), function($skip, $loc, $0, $1, $2) {
+    var MemberExpression$0 = $TS($S(MemberBase, $Q(MemberExpressionRest)), function($skip, $loc, $0, $1, $2) {
       var rest = $2;
       if (rest.length || Array.isArray($1)) {
         return processCallMemberExpression({
@@ -5291,6 +5475,13 @@ var require_parser = __commonJS({
     function MemberExpression(ctx, state) {
       return $EVENT(ctx, state, "MemberExpression", MemberExpression$0);
     }
+    var MemberBase$0 = PrimaryExpression;
+    var MemberBase$1 = SuperProperty;
+    var MemberBase$2 = MetaProperty;
+    var MemberBase$$ = [MemberBase$0, MemberBase$1, MemberBase$2];
+    function MemberBase(ctx, state) {
+      return $EVENT_C(ctx, state, "MemberBase", MemberBase$$);
+    }
     var MemberExpressionRest$0 = $TS($S($Q(MultiLineComment), MemberExpressionRestBody), function($skip, $loc, $0, $1, $2) {
       var comments = $1;
       var body = $2;
@@ -5494,7 +5685,7 @@ var require_parser = __commonJS({
     function PropertyAccess(ctx, state) {
       return $EVENT_C(ctx, state, "PropertyAccess", PropertyAccess$$);
     }
-    var PropertyGlob$0 = $TS($S(OptionalDot, $Q(MultiLineComment), BracedObjectLiteral), function($skip, $loc, $0, $1, $2, $3) {
+    var PropertyGlob$0 = $TS($S($S($E($C(QuestionMark, NonNullAssertion)), OptionalDot), $Q(MultiLineComment), BracedObjectLiteral), function($skip, $loc, $0, $1, $2, $3) {
       var dot = $1;
       var object = $3;
       return {
@@ -7300,7 +7491,76 @@ var require_parser = __commonJS({
         parameters: signature.parameters
       };
     });
-    var MethodDefinition$$ = [MethodDefinition$0, MethodDefinition$1];
+    var MethodDefinition$2 = $TS($S(GetOrSet, $E(_), ForbidIndentedApplication, $E($S(MemberBase, $Q(CallExpressionRest))), RestoreIndentedApplication, $E(BracedBlock)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+      var kind = $1;
+      var ws = $2;
+      var value = $4;
+      var block = $6;
+      if (!value)
+        return $skip;
+      const rest = value[1];
+      if (!rest.length) {
+        const base = value[0];
+        let name2;
+        if (base.type === "MemberExpression") {
+          const lastAccess2 = lastAccessInCallExpression(base);
+          if (lastAccess2) {
+            ({ name: name2 } = lastAccess2);
+          }
+        }
+        if (!name2)
+          ({ name: name2 } = base);
+        if (!name2)
+          return $skip;
+        if (name2[0] === "#")
+          name2 = name2.slice(1);
+        const autoReturn = !block || base.type !== "Identifier";
+        return makeGetterMethod(name2, ws, base, block, kind, autoReturn);
+      }
+      let last = rest[rest.length - 1];
+      while (Array.isArray(last)) {
+        last = last[last.length - 1];
+      }
+      switch (last.type) {
+        case "Call":
+          return $skip;
+        case "PropertyAccess":
+          const { name: name2 } = last;
+          return makeGetterMethod(name2, ws, value, block, kind);
+        case "PropertyGlob":
+          return {
+            type: "ShorthandMethodDefinition",
+            children: last.object.properties.map((p) => {
+              const { name: name3, type } = p;
+              let v;
+              switch (type) {
+                case "Identifier":
+                  v = insertTrimmingSpace(p, "");
+                  break;
+                case "Property":
+                  v = insertTrimmingSpace(p.value, "");
+                  break;
+              }
+              const exp = processCallMemberExpression({
+                type: "CallExpression",
+                children: [value[0], ...value[1].slice(0, -1), {
+                  type: "PropertyAccess",
+                  children: [last.dot, {
+                    ...v,
+                    children: [v.children.slice(0, 2)]
+                    // Remove potential delimiter
+                  }]
+                }]
+              });
+              return makeGetterMethod(name3, ws, exp, block, kind);
+            })
+          };
+      }
+      const lastAccess = lastAccessInCallExpression({ children: rest });
+      const { name } = lastAccess;
+      return makeGetterMethod(name, ws, value, block, kind);
+    });
+    var MethodDefinition$$ = [MethodDefinition$0, MethodDefinition$1, MethodDefinition$2];
     function MethodDefinition(ctx, state) {
       return $EVENT_C(ctx, state, "MethodDefinition", MethodDefinition$$);
     }
@@ -7386,13 +7646,14 @@ var require_parser = __commonJS({
       return $EVENT_C(ctx, state, "ClassElementName", ClassElementName$$);
     }
     var PrivateIdentifier$0 = $TV($TEXT($S(Hash, IdentifierName)), function($skip, $loc, $0, $1) {
+      var id = $0;
       return {
         type: "Identifier",
-        name: $0,
-        names: [$0],
+        name: id,
+        names: [id],
         children: [{
           $loc,
-          token: $0
+          token: id
         }]
       };
     });
@@ -7901,16 +8162,10 @@ var require_parser = __commonJS({
       var clause = $1;
       var block = $2;
       var e = $3;
-      const children = [...clause.children];
-      block = blockWithPrefix(clause.condition.expression.blockPrefix, block);
-      children.push(block);
-      if (block.bare && e)
-        children.push(";");
-      if (e)
-        children.push(e);
       return {
-        ...clause,
-        children,
+        type: "IfStatement",
+        children: [...clause.children, block, e],
+        condition: clause.condition,
         then: block,
         else: e
       };
@@ -8133,7 +8388,6 @@ var require_parser = __commonJS({
     var WhileStatement$0 = $TS($S(WhileClause, Block), function($skip, $loc, $0, $1, $2) {
       var clause = $1;
       var block = $2;
-      block = blockWithPrefix(clause.condition.expression.blockPrefix, block);
       return {
         ...clause,
         children: [...clause.children, block],
@@ -8752,27 +9006,13 @@ var require_parser = __commonJS({
       return $EVENT_C(ctx, state, "Condition", Condition$$);
     }
     var DeclarationCondition$0 = $TS($S(ForbidIndentedApplication, $E(LexicalDeclaration), RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3) {
-      var dec = $2;
-      if (!dec)
+      var declaration = $2;
+      if (!declaration)
         return $skip;
-      const ref = makeRef();
-      const { decl, bindings } = dec;
-      const binding = bindings[0];
-      const { pattern, suffix, initializer, splices, thisAssignments } = binding;
-      const initCondition = {
-        type: "AssignmentExpression",
-        children: [ref, initializer],
-        hoistDec: {
-          type: "Declaration",
-          children: ["let ", ref, suffix],
-          names: []
-        },
-        blockPrefix: [
-          ["", [decl, pattern, suffix, " = ", ref, ...splices], ";"],
-          ...thisAssignments
-        ]
+      return {
+        type: "DeclarationCondition",
+        declaration
       };
-      return initCondition;
     });
     function DeclarationCondition(ctx, state) {
       return $EVENT(ctx, state, "DeclarationCondition", DeclarationCondition$0);
@@ -12428,6 +12668,9 @@ var require_parser = __commonJS({
     exports.RHS = RHS;
     exports.ParenthesizedAssignment = ParenthesizedAssignment;
     exports.UnaryExpression = UnaryExpression;
+    exports.UnaryWithoutParenthesizedAssignment = UnaryWithoutParenthesizedAssignment;
+    exports.UnaryBody = UnaryBody;
+    exports.UnaryWithoutParenthesizedAssignmentBody = UnaryWithoutParenthesizedAssignmentBody;
     exports.UnaryPostfix = UnaryPostfix;
     exports.UpdateExpression = UpdateExpression;
     exports.UpdateExpressionSymbol = UpdateExpressionSymbol;
@@ -12484,6 +12727,7 @@ var require_parser = __commonJS({
     exports.OptionalDot = OptionalDot;
     exports.NonNullAssertion = NonNullAssertion;
     exports.MemberExpression = MemberExpression;
+    exports.MemberBase = MemberBase;
     exports.MemberExpressionRest = MemberExpressionRest;
     exports.MemberExpressionRestBody = MemberExpressionRestBody;
     exports.MemberBracketContent = MemberBracketContent;
@@ -13080,6 +13324,7 @@ var require_parser = __commonJS({
       lastAccessInCallExpression,
       literalValue,
       makeEmptyBlock,
+      makeGetterMethod,
       makeLeftHandSideExpression,
       makeRef,
       maybeRef,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@danielx/civet",
   "type": "commonjs",
-  "version": "0.6.34",
+  "version": "0.6.36",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
   "module": "dist/main.mjs",
@@ -66,7 +66,7 @@
     "unplugin": "^1.4.0"
   },
   "devDependencies": {
-    "@danielx/civet": "^0.6.26",
+    "@danielx/civet": "0.6.34",
     "@danielx/hera": "^0.8.10",
     "@types/assert": "^1.5.6",
     "@types/mocha": "^9.1.1",