bobe 0.0.72 → 0.0.74

package/dist/bobe.compiler.cjs

@@ -20,6 +20,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 | TokenType.StaticInsExp ;
@@ -75,6 +76,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 {
@@ -257,7 +259,7 @@ 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],
@@ -274,7 +276,8 @@ class Tokenizer {
           column: this.column + dt
         },
         source: this.code.slice(this.preI, this.i + dt)
-      } : null
+      } : null,
+      ...extra
     };
     this.isFirstToken = false;
   }
@@ -328,6 +331,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;
@@ -424,6 +430,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') {
@@ -1133,8 +1237,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);
@@ -1722,6 +1837,7 @@ class Interpreter {
       _node = this.createNode(value);
     }
     this.tokenizer.nextToken();
+    this.skipComponentTypeArguments(_node);
     this.headerLineAndExtensions(_node);
     this.onePropParsed = this.oneRealPropParsed;
     if (_node.__logicType & TokenizerSwitcherBit) {
@@ -1775,6 +1891,7 @@ class Interpreter {
           }, NodeSort.CtxProvider);
         }
         this.tokenizer.nextToken();
+        this.skipComponentTypeArguments(node);
         this.headerLineAndExtensions(node);
         if (isUpdate) {
           this.ctx.stack.pop();
@@ -1804,6 +1921,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,
@@ -2539,6 +2657,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 {
@@ -2770,8 +2893,11 @@ function bobe(fragments, ...values) {
 }
 function customRender(option) {
   const mw = new Mw();
-  function render(Ctor, root) {
+  function render(Ctor, root, options = {}) {
     const store = Ctor.new();
+    if (options.props) {
+      Object.assign(store, options.props);
+    }
     const tokenizer = store.ui(false);
     const terp = new Interpreter(tokenizer);
     terp.config(option);
@@ -2895,6 +3021,7 @@ exports.Interpreter = Interpreter;
 exports.Mw = Mw;
 exports.MwCtx = MwCtx;
 exports.NodeType = NodeType;
+exports.ParseErrorCode = ParseErrorCode;
 exports.ParseSyntaxError = ParseSyntaxError;
 exports.Tokenizer = Tokenizer;
 exports.bobe = bobe;