Enhancement/chai upgrade

flatn/flatn-cjs.js

@@ -15493,7 +15493,7 @@ const requestMap = {};
 
 class ESMResource extends Resource {
   static normalize (esmUrl) {
-    const id = esmUrl.replaceAll(/esm:\/\/(run|cache)\//g, '');
+    const id = esmUrl.replaceAll(/esm:\/\/([^\/]*)\//g, '');
 
     let pathStructure = id.split('/').filter(Boolean);
 
@@ -15511,7 +15511,6 @@ class ESMResource extends Resource {
       pathStructure.push(fileName);
     }
 
-
     if (pathStructure[pathStructure.length - 1].endsWith('+esm')) {
       pathStructure[pathStructure.length - 1] = pathStructure[pathStructure.length - 1].replace('+esm', 'esm.js');
     }
@@ -15527,13 +15526,22 @@ class ESMResource extends Resource {
     return pathStructure;
   }
 
-  async read () {
-    let module;
-
-    const id = this.url.replace(/esm:\/\/(run|cache)\//g, '');
-    let baseUrl = 'https://jspm.dev/';
+  getEsmURL () {
+    let baseUrl;
     if (this.url.startsWith('esm://run/npm/')) baseUrl = 'https://cdn.jsdelivr.net/';
     else if (this.url.startsWith('esm://run/')) baseUrl = 'https://esm.run/';
+    else if (this.url.startsWith('esm://cache/')) baseUrl = 'https://jspm.dev/';
+    else {
+      const domain = this.url.match(/esm:\/\/([^\/]*)\//)?.[1];
+      baseUrl = `https://${domain}/`;
+    }
+    return baseUrl;
+  }
+
+  async read () {
+    let module;
+    const id = this.url.replace(/esm:\/\/([^\/]*)\//g, '');
+    const esmURL = this.getEsmURL();
 
     let pathStructure = ESMResource.normalize(id);
 
@@ -15544,7 +15552,7 @@ class ESMResource extends Resource {
       if (typeof lively !== 'undefined' && (hit = lively.memory_esm?.get(shortName))) return await hit.blob.text();
       module = await res.read();
     } else {
-      module = await resource((baseUrl + id)).read();
+      module = await resource((esmURL + id)).read();
       res.write(module);
     }
     return module;
@@ -15627,7 +15635,9 @@ class ESMResource extends Resource {
   }
 
   async exists () {
-    // stub that needs to exist
+    const id = this.url.replace(/esm:\/\/([^\/]*)\//g, '');
+    const baseUrl = this.getEsmURL();
+    return await resource(baseUrl).join(id).exists();
   }
 
   async remove () {

lively.ast/lib/mozilla-ast-visitors.js

@@ -395,6 +395,52 @@ class ScopeVisitor extends Visitor {
     return node;
   }
 
+  visitForStatement (node, scope, path) {
+    const visitor = this;
+    // init is of types VariableDeclaration, Expression
+    if (node.init) {
+      node.init = visitor.accept(node.init, scope, path.concat(['init']));
+    }
+    // test is of types Expression
+    if (node.test) {
+      node.test = visitor.accept(node.test, scope, path.concat(['test']));
+    }
+    // update is of types Expression
+    if (node.update) {
+      node.update = visitor.accept(node.update, scope, path.concat(['update']));
+    }
+    // body is of types Statement
+    node.body = visitor.accept(node.body, this.newScope(node, scope), path.concat(['body']));
+    return node;
+  }
+
+  visitForInStatement (node, scope, path) {
+    const visitor = this;
+    // left is of types VariableDeclaration, Pattern
+    node.left = visitor.accept(node.left, scope, path.concat(['left']));
+    // right is of types Expression
+    node.right = visitor.accept(node.right, scope, path.concat(['right']));
+    // body is of types Statement
+    node.body = visitor.accept(node.body, this.newScope(node, scope), path.concat(['body']));
+    return node;
+  }
+
+  visitIfStatement (node, scope, path) {
+    const visitor = this;
+
+    node.test = visitor.accept(node.test, scope, path.concat(['test']));
+
+    const consequentScope = this.newScope(node, scope);
+    node.consequent = visitor.accept(node.consequent, consequentScope, path.concat(['consequent']));
+
+    if (node.alternate) {
+      const alternateScope = this.newScope(node, scope);
+      node.alternate = visitor.accept(node.alternate, alternateScope, path.concat(['alternate']));
+    }
+
+    return node;
+  }
+
   visitLabeledStatement (node, scope, path) {
     const visitor = this;
     // ignore label

lively.ast/lib/nodes.js

@@ -32,7 +32,7 @@ function binaryExpr (left, op, right) {
   };
 }
 
-function funcExpr ({ arrow, id: funcId, expression, generator }, params = [], ...statements) {
+function funcExpr ({ arrow, id: funcId, expression, generator, isAsync }, params = [], ...statements) {
   // lively.ast.stringify(funcExpr({id: "foo"}, ["a"], exprStmt(id("3"))))
   // // => "function foo(a) { 3; }"
   params = params.map(ea => typeof ea === 'string' ? id(ea) : ea);
@@ -44,7 +44,8 @@ function funcExpr ({ arrow, id: funcId, expression, generator }, params = [], ..
       ? statements[0]
       : { body: statements, type: 'BlockStatement' },
     expression: expression || false,
-    generator: generator || false
+    generator: generator || false,
+    async: isAsync
   };
 }
 

lively.ast/lib/query.js

@@ -443,7 +443,7 @@ function statementOf (parsed, node, options) {
   // Find the statement that a target node is in. Example:
   // let source be "var x = 1; x + 1;" and we are looking for the
   // Identifier "x" in "x+1;". The second statement is what will be found.
-  const nodes = nodesAt(node.start, parsed);
+  const nodes = nodesAt(node.start + 1, parsed);
   const found = nodes.reverse().find(node => _stmtTypes.includes(node.type));
   if (options && options.asPath) {
     const v = new BaseVisitor(); let foundPath;

lively.ast/tests/es6-test.js

@@ -1,16 +1,14 @@
-/*global process, require, beforeEach, afterEach, describe, it*/
+/* global process, require, beforeEach, afterEach, describe, it */
 
-import { expect } from "mocha-es6";
+import { expect } from 'mocha-es6';
 
-import { parse } from "../lib/parser.js";
+import { parse } from '../lib/parser.js';
 
-describe('es6', function() {
-
-  it("arrow function", function() {
-    var code = '() => 23;'
-    var parsed = parse(code);
-    expect(parsed).deep.property("body[0].expression.type")
-      .equals("ArrowFunctionExpression");
+describe('es6', function () {
+  it('arrow function', function () {
+    let code = '() => 23;';
+    let parsed = parse(code);
+    expect(parsed).has.nested.property('body[0].expression.type')
+      .equals('ArrowFunctionExpression');
   });
-
 });

lively.ast/tests/parser-test.js

@@ -1,53 +1,48 @@
-/*global beforeEach, afterEach, describe, it*/
+/* global beforeEach, afterEach, describe, it */
 
-import { expect } from "mocha-es6";
+import { expect } from 'mocha-es6';
 
-import { printAst } from "../lib/mozilla-ast-visitor-interface.js";
-import { parse, parseFunction } from "../lib/parser.js";
-
-describe('parse', function() {
+import { printAst } from '../lib/mozilla-ast-visitor-interface.js';
+import { parse, parseFunction } from '../lib/parser.js';
 
+describe('parse', function () {
   it('JavaScript code', () =>
-    expect(parse("1 + 2"))
-      .deep.property("body[0].type")
-      .equals("ExpressionStatement"));
-
-  describe("async / await", () => {
-
-    it("parses nested awaits", () => {
-        var src = "await (await foo()).bar()",
-            parsed = parse(src),
-            expected = ":Program(0-25)\n"
-                     + "\\-.body[0]:ExpressionStatement(0-25)\n"
-                     + "  \\-.body[0].expression:AwaitExpression(0-25)\n"
-                     + "    \\-.body[0].expression.argument:CallExpression(6-25)\n"
-                     + "      \\-.body[0].expression.argument.callee:MemberExpression(6-23)\n"
-                     + "        |-.body[0].expression.argument.callee.object:AwaitExpression(7-18)\n"
-                     + "        | \\-.body[0].expression.argument.callee.object.argument:CallExpression(13-18)\n"
-                     + "        |   \\-.body[0].expression.argument.callee.object.argument.callee:Identifier(13-16)\n"
-                     + "        \\-.body[0].expression.argument.callee.property:Identifier(20-23)"
-        expect(printAst(parsed, {printPositions: true})).to.equal(expected);
+    expect(parse('1 + 2'))
+      .nested.property('body[0].type')
+      .equals('ExpressionStatement'));
+
+  describe('async / await', () => {
+    it('parses nested awaits', () => {
+      let src = 'await (await foo()).bar()';
+      let parsed = parse(src);
+      let expected = ':Program(0-25)\n' +
+                     '\\-.body[0]:ExpressionStatement(0-25)\n' +
+                     '  \\-.body[0].expression:AwaitExpression(0-25)\n' +
+                     '    \\-.body[0].expression.argument:CallExpression(6-25)\n' +
+                     '      \\-.body[0].expression.argument.callee:MemberExpression(6-23)\n' +
+                     '        |-.body[0].expression.argument.callee.object:AwaitExpression(7-18)\n' +
+                     '        | \\-.body[0].expression.argument.callee.object.argument:CallExpression(13-18)\n' +
+                     '        |   \\-.body[0].expression.argument.callee.object.argument.callee:Identifier(13-16)\n' +
+                     '        \\-.body[0].expression.argument.callee.property:Identifier(20-23)';
+      expect(printAst(parsed, { printPositions: true })).to.equal(expected);
     });
-
   });
 
-  describe("parseFunction", () => {
-
-    it("anonmyous function", () => {
-      expect(parseFunction("function(x) { return x + 1; }").type).equals("FunctionExpression")
+  describe('parseFunction', () => {
+    it('anonmyous function', () => {
+      expect(parseFunction('function(x) { return x + 1; }').type).equals('FunctionExpression');
     });
 
-    it("named function", () => {
-      expect(parseFunction("function foo(x) { return x + 1; }")).containSubset({type: "FunctionExpression", id: {name: "foo"}})
+    it('named function', () => {
+      expect(parseFunction('function foo(x) { return x + 1; }')).containSubset({ type: 'FunctionExpression', id: { name: 'foo' } });
     });
 
-    it("arrow function", () => {
-      expect(parseFunction("(x) => { return x + 1; }")).containSubset({type: "ArrowFunctionExpression"})
+    it('arrow function', () => {
+      expect(parseFunction('(x) => { return x + 1; }')).containSubset({ type: 'ArrowFunctionExpression' });
     });
 
-    it("short function", () => {
-      expect(parseFunction("x => x + 1")).containSubset({type: "ArrowFunctionExpression"})
+    it('short function', () => {
+      expect(parseFunction('x => x + 1')).containSubset({ type: 'ArrowFunctionExpression' });
     });
-
   });
 });