bobe 0.0.73 → 0.0.74

package/dist/bobe.esm.js

@@ -19,6 +19,7 @@ let TokenType = function (TokenType) {
   TokenType[TokenType["Null"] = 8192] = "Null";
   TokenType[TokenType["Undefined"] = 16384] = "Undefined";
   TokenType[TokenType["Comment"] = 32768] = "Comment";
+  TokenType[TokenType["TypeArguments"] = 65536] = "TypeArguments";
   return TokenType;
 }({});
 const ChildrenSugarType = TokenType.String | TokenType.InsertionExp;
@@ -74,6 +75,7 @@ let ParseErrorCode = function (ParseErrorCode) {
   ParseErrorCode[ParseErrorCode["MISSING_COMMENT_SECOND_SLASH"] = 9015] = "MISSING_COMMENT_SECOND_SLASH";
   ParseErrorCode[ParseErrorCode["MISSING_PROP_ASSIGNMENT"] = 9016] = "MISSING_PROP_ASSIGNMENT";
   ParseErrorCode[ParseErrorCode["PIPE_IN_WRONG_CONTEXT"] = 9017] = "PIPE_IN_WRONG_CONTEXT";
+  ParseErrorCode[ParseErrorCode["UNCLOSED_TYPE_ARGUMENTS"] = 9018] = "UNCLOSED_TYPE_ARGUMENTS";
   return ParseErrorCode;
 }({});
 class ParseSyntaxError extends SyntaxError {
@@ -247,12 +249,13 @@ class Tokenizer {
     if (!this.token) return false;
     return this.token.type & TokenType.Identifier && this.token.value === Tokenizer.EofId;
   }
-  setToken(type, value, dt = 1) {
+  setToken(type, value, dt = 1, extra) {
     this.token = {
       type,
       typeName: TokenType[type],
       value,
-      loc: null
+      loc: null,
+      ...extra
     };
     this.isFirstToken = false;
   }
@@ -306,6 +309,9 @@ class Tokenizer {
                   const braceToken = this.brace();
                   this.setToken(TokenType.InsertionExp, braceToken);
                   break;
+                case '<':
+                  this.typeArguments();
+                  break;
                 case '$':
                   const handled = this.staticIns();
                   if (handled) break;
@@ -394,6 +400,104 @@ class Tokenizer {
     this.locEnd();
     return this.token;
   }
+  typeArguments() {
+    const startOffset = this.i;
+    const startLine = this.line;
+    const startColumn = this.column;
+    let angleDepth = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    let parenDepth = 0;
+    let current = '';
+    const args = [];
+    let argStart = this.i + 1;
+    const makeLoc = (start, end) => ({
+      start: {
+        offset: start,
+        line: startLine,
+        column: startColumn + (start - startOffset)
+      },
+      end: {
+        offset: end,
+        line: startLine,
+        column: startColumn + (end - startOffset)
+      },
+      source: this.code.slice(start, end)
+    });
+    const pushArg = end => {
+      const raw = current.trim();
+      if (!raw) return;
+      const leading = current.length - current.trimStart().length;
+      const trailingEnd = current.trimEnd().length;
+      args.push({
+        raw,
+        loc: makeLoc(argStart + leading, argStart + trailingEnd)
+      });
+    };
+    while (true) {
+      const char = this.code[this.i];
+      if (char === undefined || char === '\n') {
+        throw new ParseSyntaxError(ParseErrorCode.UNCLOSED_TYPE_ARGUMENTS, '未闭合的组件泛型参数', makeLoc(startOffset, this.i));
+      }
+      if (char === '\'' || char === '"' || char === '`') {
+        const quote = char;
+        current += char;
+        this.next();
+        while (true) {
+          const inner = this.code[this.i];
+          if (inner === undefined || inner === '\n') {
+            throw new ParseSyntaxError(ParseErrorCode.UNCLOSED_TYPE_ARGUMENTS, '未闭合的组件泛型参数', makeLoc(startOffset, this.i));
+          }
+          current += inner;
+          if (inner === '\\') {
+            this.next();
+            current += this.code[this.i] ?? '';
+          } else if (inner === quote) {
+            break;
+          }
+          this.next();
+        }
+      } else if (char === '<') {
+        angleDepth++;
+        if (angleDepth > 1) current += char;
+      } else if (char === '>' && this.code[this.i - 1] !== '=') {
+        angleDepth--;
+        if (angleDepth === 0) {
+          pushArg(this.i);
+          this.setToken(TokenType.TypeArguments, this.code.slice(startOffset + 1, this.i), 1, {
+            typeArguments: args
+          });
+          return;
+        }
+        current += char;
+      } else if (char === '{') {
+        braceDepth++;
+        current += char;
+      } else if (char === '}') {
+        braceDepth = Math.max(0, braceDepth - 1);
+        current += char;
+      } else if (char === '[') {
+        bracketDepth++;
+        current += char;
+      } else if (char === ']') {
+        bracketDepth = Math.max(0, bracketDepth - 1);
+        current += char;
+      } else if (char === '(') {
+        parenDepth++;
+        current += char;
+      } else if (char === ')') {
+        parenDepth = Math.max(0, parenDepth - 1);
+        current += char;
+      } else if (char === ',' && angleDepth === 1 && braceDepth === 0 && bracketDepth === 0 && parenDepth === 0) {
+        pushArg(this.i);
+        current = '';
+        argStart = this.i + 1;
+      } else {
+        current += char;
+      }
+      this.next();
+    }
+  }
   peekChar() {
     let i = this.i;
     while (this.code[i] === ' ' || this.code[i] === '\t') {
@@ -1105,8 +1209,19 @@ class Compiler {
   parseComponentNode(node) {
     const name = this.parseName();
     this.tokenizer.nextToken();
+    const typeArgumentsToken = this.tokenizer.token.type & TokenType.TypeArguments ? this.tokenizer.token : undefined;
+    if (typeArgumentsToken) {
+      this.tokenizer.nextToken();
+    }
     node.type = NodeType.Component;
     node.componentName = name;
+    node.typeArguments = typeArgumentsToken?.typeArguments?.map(arg => ({
+      type: NodeType.StaticValue,
+      raw: arg.raw,
+      loc: arg.loc
+    }));
+    node.typeArgumentsLoc = typeArgumentsToken?.loc;
+    this.hooks.parseComponentNode?.nameAdded?.call(this, node);
     const props = this.headerLineAndExtensions();
     node.props = props;
     this.hooks.parseComponentNode?.propsAdded?.call(this, node);
@@ -1694,6 +1809,7 @@ class Interpreter {
       _node = this.createNode(value);
     }
     this.tokenizer.nextToken();
+    this.skipComponentTypeArguments(_node);
     this.headerLineAndExtensions(_node);
     this.onePropParsed = this.oneRealPropParsed;
     if (_node.__logicType & TokenizerSwitcherBit) {
@@ -1747,6 +1863,7 @@ class Interpreter {
           }, NodeSort.CtxProvider);
         }
         this.tokenizer.nextToken();
+        this.skipComponentTypeArguments(node);
         this.headerLineAndExtensions(node);
         if (isUpdate) {
           this.ctx.stack.pop();
@@ -1776,6 +1893,7 @@ class Interpreter {
             this.handleInsert(node.realParent, textNode, node.realBefore);
           } else {
             this.tokenizer.nextToken();
+            this.skipComponentTypeArguments(node, true);
             this.headerLineAndExtensions(node);
             const _this$ctx2 = this.ctx,
               realParent = _this$ctx2.realParent,
@@ -2511,6 +2629,11 @@ class Interpreter {
       point = next;
     }
   }
+  skipComponentTypeArguments(node, force = false) {
+    if ((force || node.__logicType & TokenizerSwitcherBit) && this.tokenizer.token.type & TokenType.TypeArguments) {
+      this.tokenizer.nextToken();
+    }
+  }
   headerLineAndExtensions(_node) {
     const tokenizer = this.tokenizer;
     do {
@@ -2860,5 +2983,5 @@ const effect = (callback, depOrOpt, opt) => {
   return effect$1(callback, option);
 };
 
-export { Compiler, FakeType, Interpreter, Mw, MwCtx, NodeType, ParseSyntaxError, Tokenizer, bobe, context, customRender, effect };
+export { Compiler, FakeType, Interpreter, Mw, MwCtx, NodeType, ParseErrorCode, ParseSyntaxError, Tokenizer, bobe, context, customRender, effect };
 //# sourceMappingURL=bobe.esm.js.map