acorn-jsx - npm Package Compare versions

Comparing version 0.11.1-3 to 0.11.1-4

acorn_loose.js

@@ -259,7 +259,23 @@ // Acorn: Loose parser
 
+  function finishNodeAt(node, type, pos) {
+    if (options.locations) { node.loc.end = pos[1]; pos = pos[0]; }
+    node.type = type;
+    node.end = pos;
+    if (options.ranges)
+      node.range[1] = pos;
+    return node;
+  }
+
+  function emptyNode(type) {
+    var dummy = startNodeAt(options.locations ? [lastEnd, lastEndLoc] : lastEnd);
+    dummy.name = "✖";
+    return finishNodeAt(dummy, type, storeCurrentPos());
+  }
+
   function dummyIdent() {
-    var dummy = startNode();
+    var dummy = emptyNode("Identifier");
     dummy.name = "✖";
-    return finishNode(dummy, "Identifier");
+    return dummy;
   }
+
   function isDummy(node) { return node.name == "✖"; }
@@ -728,3 +744,3 @@
 
-    case tt.num: case tt.string:
+    case tt.num: case tt.string: case tt.jsxText:
       var node = startNode();
@@ -793,2 +809,5 @@ node.value = token.value;
 
+    case tt.jsxTagStart:
+      return parseJSXElement();
+
     default:
@@ -1167,2 +1186,152 @@ return dummyIdent();
   }
+
+  // Parse next token as JSX identifier
+
+  function parseJSXIdentifier() {
+    var node = startNode();
+    node.name = token.type === tt.jsxName ? token.value : token.type.keyword;
+    next();
+    return finishNode(node, "JSXIdentifier");
+  }
+
+  // Parse namespaced identifier.
+
+  function parseJSXNamespacedName() {
+    var start = storeCurrentPos();
+    var name = parseJSXIdentifier();
+    if (!eat(tt.colon)) return name;
+    var node = startNodeAt(start);
+    node.namespace = name;
+    node.name = parseJSXIdentifier();
+    return finishNode(node, "JSXNamespacedName");
+  }
+
+  // Parses element name in any form - namespaced, member
+  // or single identifier.
+
+  function parseJSXElementName() {
+    var start = storeCurrentPos();
+    var node = parseJSXNamespacedName();
+    while (eat(tt.dot)) {
+      var newNode = startNodeAt(start);
+      newNode.object = node;
+      newNode.property = parseJSXIdentifier();
+      node = finishNode(newNode, "JSXMemberExpression");
+    }
+    return node;
+  }
+
+  // Parses any type of JSX attribute value.
+
+  function parseJSXAttributeValue() {
+    return token.type === tt.braceL ? parseJSXExpressionContainer() : parseExprAtom();
+  }
+
+  // Parses JSX expression enclosed into curly brackets.
+
+  function parseJSXExpressionContainer(allowEmpty) {
+    var node = startNode();
+    pushCx();
+    next();
+    node.expression = allowEmpty && token.type === tt.braceR ? emptyNode("JSXEmptyExpression") : parseExpression();
+    popCx();
+    expect(tt.braceR);
+    return finishNode(node, "JSXExpressionContainer");
+  }
+
+  // Parses following JSX attribute name-value pair.
+
+  function parseJSXAttribute() {
+    var node = startNode();
+    if (token.type === tt.braceL) {
+      if (lookAhead(1).type === tt.ellipsis) {
+        next();
+        next();
+        node.argument = parseMaybeAssign();
+        expect(tt.braceR);
+        return finishNode(node, "JSXSpreadAttribute");
+      } else {
+        node.name = dummyIdent();
+        node.value = parseJSXAttributeValue();
+      }
+    } else {
+      node.name = parseJSXNamespacedName();
+      node.value = eat(tt.eq) ? parseJSXAttributeValue() : null;
+    }
+    return finishNode(node, "JSXAttribute");
+  }
+
+  // Parses JSX opening tag starting after '<'.
+
+  function parseJSXOpeningElementAt(start) {
+    var node = startNodeAt(start);
+    node.attributes = [];
+    node.name = parseJSXElementName();
+    while (token.type !== tt.slash && token.type !== tt.jsxTagEnd && token.type !== tt.eof) {
+      node.attributes.push(parseJSXAttribute());
+    }
+    node.selfClosing = eat(tt.slash);
+    expect(tt.jsxTagEnd);
+    if (token.type === tt.eof) node.selfClosing = true;
+    return finishNode(node, "JSXOpeningElement");
+  }
+
+  // Parses JSX closing tag starting after '</'.
+
+  function parseJSXClosingElementAt(start) {
+    var node = startNodeAt(start);
+    node.name = parseJSXElementName();
+    expect(tt.jsxTagEnd);
+    return finishNode(node, "JSXClosingElement");
+  }
+
+  // Parses entire JSX element, including it's opening tag
+  // (starting after '<'), attributes, contents and closing tag.
+
+  function parseJSXElementAt(start) {
+    var node = startNodeAt(start);
+    var children = [];
+    var openingElement = parseJSXOpeningElementAt(start);
+    var closingElement = null;
+
+    if (!openingElement.selfClosing) {
+      contents:for (;;) {
+        switch (token.type) {
+          case tt.jsxTagStart:
+            start = storeCurrentPos();
+            next();
+            if (eat(tt.slash)) {
+              closingElement = parseJSXClosingElementAt(start);
+              break contents;
+            }
+            children.push(parseJSXElementAt(start));
+            break;
+
+          case tt.braceL:
+            children.push(parseJSXExpressionContainer(true));
+            break;
+
+          case tt.eof:
+            break contents;
+
+          default:
+            children.push(parseExprAtom());
+            break;
+        }
+      }
+    }
+
+    node.openingElement = openingElement;
+    node.closingElement = closingElement;
+    node.children = children;
+    return finishNode(node, "JSXElement");
+  }
+
+  // Parses entire JSX element from current position.
+
+  function parseJSXElement() {
+    var start = storeCurrentPos();
+    next();
+    return parseJSXElementAt(start);
+  }
 });

package.json

@@ -6,3 +6,3 @@ {
     "main": "acorn.js",
-    "version": "0.11.1-3",
+    "version": "0.11.1-4",
     "engines": {"node": ">=0.4.0"},
@@ -9,0 +9,0 @@ "maintainers": [{"name": "Ingvar Stepanyan",

t.js

@@ -1,5 +0,16 @@
-module.exports = function(s) {
-  delete require.cache[require.resolve('./acorn')];
+function reRequire(path) {
+  path = require.resolve(path);
+  delete require.cache[path];
+  return require(path);
+}
+
+function parseOpts(opts) {
+  opts = opts || {};
+  opts.ecmaVersion = 6;
+  return opts;
+}
+
+module.exports = function(s, opts) {
   try {
-    return require('./acorn').parse(s, {ecmaVersion: 6});
+    return reRequire('./acorn').parse(s, parseOpts(opts));
   } catch (e) {
@@ -9,1 +20,5 @@ console.error(e.stack);
 };
+
+module.exports.loose = function(s, opts) {
+  return reRequire('./acorn_loose').parse_dammit(s, parseOpts(opts));
+};

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Dynamic require

Supply chain risk

Dynamic require can indicate the package is performing dangerous or unsafe dynamic code execution.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

2796188

increased by0.21%

Number of package files

35

increased by2.94%

Lines of code

94287

increased by0.16%

Worsened metrics

Number of low supply chain risk alerts

3

increased by200%

No dependency changes