summitjs 0.1.0 → 0.3.0

package/dist/summit.js

@@ -339,6 +339,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 = [
   "...",
   "===",
@@ -485,6 +514,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)) {
@@ -828,8 +886,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++;
@@ -904,6 +988,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++;
@@ -985,6 +1073,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();
@@ -1268,6 +1361,10 @@ var GLOBAL_ALLOW = /* @__PURE__ */ new Set([
   "requestAnimationFrame",
   "cancelAnimationFrame",
   "fetch",
+  "AbortController",
+  "Headers",
+  "Request",
+  "Response",
   "alert",
   "confirm",
   "prompt",
@@ -1395,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":
@@ -1464,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,
@@ -1705,6 +1812,10 @@ function evaluateAction(source, root, thisVal) {
   const program = parse(source, "program");
   return new Interpreter(root).run(program, thisVal);
 }
+function compileExpression(source) {
+  const program = parse(source, "expression");
+  return (root, thisVal) => new Interpreter(root).run(program, thisVal);
+}
 
 // src/errors.ts
 var DOCS = "https://velofy.github.io/summit";
@@ -2043,15 +2154,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);
@@ -2771,11 +2893,13 @@ var sFor = (el, meta2, utils) => {
   el.remove();
   const parentScopes = utils.scopes;
   let blocks = /* @__PURE__ */ new Map();
-  const keyFor = (it, block) => {
-    if (!keyExpr) return it.objectKey ?? it.index;
-    const env = makeEnv(el, block).env;
+  const keyEval = keyExpr ? compileExpression(keyExpr) : null;
+  const keyFor = (it) => {
+    if (!keyEval) return it.objectKey ?? it.index;
+    const data = { [itemName]: it.value };
+    if (indexName) data[indexName] = it.objectKey ?? it.index;
     try {
-      return evaluateExpression(keyExpr, env);
+      return keyEval(makeEnv(el, data).env);
     } catch {
       return it.index;
     }
@@ -2797,8 +2921,7 @@ var sFor = (el, meta2, utils) => {
     const next = /* @__PURE__ */ new Map();
     const orderedKeys = [];
     for (const it of items) {
-      let scope = makeBlockScope(it);
-      const key = keyFor(it, scope);
+      const key = keyFor(it);
       orderedKeys.push(key);
       const existing = blocks.get(key);
       if (existing) {
@@ -2807,7 +2930,9 @@ var sFor = (el, meta2, utils) => {
         next.set(key, existing);
         blocks.delete(key);
       } else {
+        const scope = makeBlockScope(it);
         const node = blueprint.cloneNode(true);
+        parent.insertBefore(node, anchor2);
         utils.initTree(node, [...parentScopes, scope]);
         next.set(key, { node, scope });
       }
@@ -2816,9 +2941,13 @@ var sFor = (el, meta2, utils) => {
       utils.destroyTree(block.node);
       block.node.remove();
     }
-    for (const key of orderedKeys) {
-      const block = next.get(key);
-      parent.insertBefore(block.node, anchor2);
+    let expected = anchor2;
+    for (let i = orderedKeys.length - 1; i >= 0; i--) {
+      const node = next.get(orderedKeys[i]).node;
+      if (node.nextSibling !== expected) {
+        parent.insertBefore(node, expected);
+      }
+      expected = node;
     }
     blocks = next;
   });