summitjs 0.1.0 → 0.2.0

package/dist/summit.cjs

@@ -343,6 +343,35 @@ function createScope(raw) {
 }
 
 // src/evaluator/lexer.ts
+var REGEX_PRECEDING_KEYWORDS = /* @__PURE__ */ new Set([
+  "return",
+  "typeof",
+  "void",
+  "in",
+  "instanceof",
+  "new",
+  "of",
+  "delete",
+  "do",
+  "else"
+]);
+function regexAllowed(prev) {
+  if (!prev) return true;
+  switch (prev.type) {
+    case "num":
+    case "str":
+    case "tmpl":
+    case "regex":
+      return false;
+    // a value precedes -> division
+    case "ident":
+      return REGEX_PRECEDING_KEYWORDS.has(prev.value);
+    case "punc":
+      return prev.value !== ")" && prev.value !== "]";
+    default:
+      return true;
+  }
+}
 var PUNCTUATORS = [
   "...",
   "===",
@@ -489,6 +518,35 @@ function tokenize(input) {
       tokens2.push({ type: "ident", value: input.slice(start2, i), start: start2, end: i });
       continue;
     }
+    if (ch === "/" && regexAllowed(tokens2[tokens2.length - 1])) {
+      const start2 = i;
+      i++;
+      let body = "";
+      let inClass = false;
+      while (i < n) {
+        const c = input[i];
+        if (c === "\\") {
+          body += c + (input[i + 1] ?? "");
+          i += 2;
+          continue;
+        }
+        if (c === "\n") throw new LexError(`Unterminated regex in expression: ${input}`);
+        if (c === "[") inClass = true;
+        else if (c === "]") inClass = false;
+        else if (c === "/" && !inClass) break;
+        body += c;
+        i++;
+      }
+      if (input[i] !== "/") throw new LexError(`Unterminated regex in expression: ${input}`);
+      i++;
+      let flags = "";
+      while (i < n && /[a-z]/i.test(input[i])) {
+        flags += input[i];
+        i++;
+      }
+      tokens2.push({ type: "regex", value: body, flags, start: start2, end: i });
+      continue;
+    }
     let matched = false;
     for (const p of PUNCTUATORS) {
       if (input.startsWith(p, i)) {
@@ -832,8 +890,34 @@ var Parser = class {
     }
     return node;
   }
+  parseNewExpr() {
+    this.pos++;
+    let callee = this.parsePrimary();
+    for (; ; ) {
+      if (this.isPunc(".")) {
+        this.pos++;
+        const name = this.next();
+        callee = {
+          type: "MemberExpression",
+          object: callee,
+          property: { type: "Identifier", name: name.value },
+          computed: false,
+          optional: false
+        };
+      } else if (this.isPunc("[")) {
+        this.pos++;
+        const property = this.parseExpression();
+        this.eatPunc("]");
+        callee = { type: "MemberExpression", object: callee, property, computed: true, optional: false };
+      } else {
+        break;
+      }
+    }
+    const args = this.isPunc("(") ? this.parseArguments() : [];
+    return { type: "NewExpression", callee, arguments: args };
+  }
   parseCallMember() {
-    let node = this.parsePrimary();
+    let node = this.isKeyword("new") ? this.parseNewExpr() : this.parsePrimary();
     for (; ; ) {
       if (this.isPunc(".")) {
         this.pos++;
@@ -908,6 +992,10 @@ var Parser = class {
       this.pos++;
       return this.parseTemplate(t.raw ?? "");
     }
+    if (t.type === "regex") {
+      this.pos++;
+      return { type: "RegexLiteral", pattern: t.value, flags: t.flags ?? "" };
+    }
     if (t.type === "ident") {
       if (t.value === "true" || t.value === "false") {
         this.pos++;
@@ -989,6 +1077,11 @@ var Parser = class {
     return { type: "ObjectExpression", properties };
   }
   parseObjectProperty() {
+    if (this.isKeyword("async") && this.peek(1).type === "ident") {
+      throw new ParseError(
+        "async methods are not supported in Summit expressions. Use a regular method that returns a Promise and chain .then()."
+      );
+    }
     if ((this.isKeyword("get") || this.isKeyword("set")) && !this.isPunc(":", 1) && !this.isPunc(",", 1) && !this.isPunc("(", 1) && !this.isPunc("}", 1)) {
       const kind = this.next().value;
       const { key: key2, computed: computed3 } = this.parsePropertyKey();
@@ -1399,6 +1492,8 @@ var Interpreter = class {
         return null;
       case "UndefinedLiteral":
         return void 0;
+      case "RegexLiteral":
+        return new RegExp(node.pattern, node.flags);
       case "ThisExpression":
         return thisVal;
       case "Identifier":
@@ -1468,6 +1563,14 @@ var Interpreter = class {
       }
       case "CallExpression":
         return this.evalCall(node, scope, thisVal);
+      case "NewExpression": {
+        const ctor = this.evalExpr(node.callee, scope, thisVal);
+        const args = this.evalArguments(node.arguments, scope, thisVal);
+        if (typeof ctor !== "function") {
+          throw new TypeError("Expression value is not a constructor");
+        }
+        return Reflect.construct(ctor, args);
+      }
       case "ArrowFunction":
         return this.makeFunction(
           node,
@@ -2047,15 +2150,26 @@ function initData(el, dmeta, parentScopes) {
   const parentEnv = makeEnv(el);
   const expr = dmeta.expression.trim();
   let raw;
-  const match = expr.match(DATA_PROVIDER_RE);
-  if (match && getData(match[1])) {
-    const provider = getData(match[1]);
-    const args = match[2] ? parentEnv.evaluate("[" + (match[3] ?? "") + "]") : [];
-    raw = provider(...args);
-  } else if (expr === "") {
+  try {
+    const match = expr.match(DATA_PROVIDER_RE);
+    if (match && getData(match[1])) {
+      const provider = getData(match[1]);
+      const args = match[2] ? parentEnv.evaluate("[" + (match[3] ?? "") + "]") : [];
+      raw = provider(...args);
+    } else if (expr === "") {
+      raw = {};
+    } else {
+      raw = parentEnv.evaluate("(" + expr + ")");
+    }
+  } catch (err) {
+    fail("E104", "s-data could not be evaluated; the component starts with empty state.", {
+      el,
+      expression: expr,
+      doc: "s-data",
+      hint: "Check the object for unsupported syntax, e.g. an async method.",
+      cause: err
+    });
     raw = {};
-  } else {
-    raw = parentEnv.evaluate("(" + expr + ")");
   }
   if (raw === null || typeof raw !== "object") raw = {};
   const scope = createScope(raw);
@@ -2812,6 +2926,7 @@ var sFor = (el, meta2, utils) => {
         blocks.delete(key);
       } else {
         const node = blueprint.cloneNode(true);
+        parent.insertBefore(node, anchor2);
         utils.initTree(node, [...parentScopes, scope]);
         next.set(key, { node, scope });
       }