bobe 0.0.47 → 0.0.49

package/dist/bobe.compiler.esm.js

@@ -1,6 +1,6 @@
 import { Queue, isNum, matchIdStart2, matchId, escapeMap, jsVarRegexp, date32 } from 'bobe-shared';
-import { getPulling, setPulling, Keys, deepSignal, Computed, Effect, toRaw, runWithPulling, Scope, Store, effect, shareSignal } from 'aoye';
-export * from 'aoye';
+import { Signal, Computed, Keys, getPulling, setPulling, deepSignal, toRaw, ScheduleType, runWithPulling, Scope, Store, noopEffect, NoopEffect, Effect, effect as effect$1, shareSignal } from 'aoye';
+export { Store } from 'aoye';
 
 let TokenType = function (TokenType) {
   TokenType[TokenType["NewLine"] = 1] = "NewLine";
@@ -80,6 +80,7 @@ class ParseSyntaxError extends SyntaxError {
     this.loc = loc;
   }
 }
+const isDep = target => target && (target instanceof Signal || target instanceof Computed || typeof target === 'function' || typeof target === 'string');
 
 class Tokenizer {
   TabSize = 2;
@@ -104,10 +105,13 @@ class Tokenizer {
     this.hook = hook;
     this.useDedentAsEof = useDedentAsEof;
     if (useDedentAsEof) {
-      this.setToken(TokenType.Indent, '');
-      this.isFirstToken = true;
+      this.initIndentWhenUseDedentAsEof();
     }
   }
+  initIndentWhenUseDedentAsEof() {
+    this.setToken(TokenType.Indent, '');
+    this.isFirstToken = true;
+  }
   next() {
     {
       const char = this.code[this.i];
@@ -146,16 +150,23 @@ class Tokenizer {
   throwUnclosed(code, message, startOffset, startLine, startCol) {
     throw new ParseSyntaxError(code, message, this.unclosedLoc(startOffset, startLine, startCol));
   }
-  resume(_snapshot) {
+  resume({
+    dentStack,
+    waitingTokens,
+    ..._snapshot
+  }) {
     this.token = undefined;
     this.needIndent = false;
     this.isFirstToken = true;
-    this.dentStack = [0];
+    this.dentStack = dentStack ? dentStack.slice() : [0];
+    if (waitingTokens) {
+      this.waitingTokens = waitingTokens.clone();
+    }
     Object.assign(this, _snapshot);
   }
-  snapshot(keys) {
+  snapshot(keys, dtI = 0) {
     const snap = {
-      i: this.i,
+      i: this.i + dtI,
       waitingTokens: this.waitingTokens.clone()
     };
     if (keys) {
@@ -168,8 +179,10 @@ class Tokenizer {
     }
     return snap;
   }
-  skip() {
-    const logicDentLen = this.dentStack[this.dentStack.length - 1];
+  skip(targetDentLen) {
+    if (targetDentLen == undefined) {
+      targetDentLen = this.dentStack[this.dentStack.length - 1];
+    }
     let needIndent = false;
     let skipFragment = ``;
     this.token = undefined;
@@ -192,7 +205,7 @@ class Tokenizer {
         isEmptyLine = _this$getDentValue.isEmptyLine;
       const currLen = value.length;
       if (isEmptyLine) continue;
-      if (currLen > logicDentLen) {
+      if (currLen > targetDentLen) {
         skipFragment += value;
       } else {
         for (let i = this.dentStack.length - 1; i >= 0; i--) {
@@ -205,6 +218,9 @@ class Tokenizer {
             break;
           }
           this.dentStack.pop();
+          if (expLen > targetDentLen) {
+            continue;
+          }
           if (!this.token) {
             this.setToken(TokenType.Dedent, String(expLen));
           } else {
@@ -271,33 +287,31 @@ class Tokenizer {
       }
       outer: while (1) {
         if (this.needIndent) {
+          this.locStart();
           this.dent();
+          this.locEnd();
         } else {
           const char = this.code[this.i];
           switch (char) {
             case '\t':
             case ' ':
               break;
-            case '\n':
-              this.newLine();
-              this.needIndent = true;
-              break;
-            case '=':
-              this.assignment();
-              break;
-            case '|':
-              this.pipe();
-              break;
-            case ';':
-              this.setToken(TokenType.Semicolon, ';');
-              break;
             default:
-              if (true) {
-                this.preI = this.i;
-                this.preCol = this.column;
-                this.needLoc = true;
-              }
+              this.locStart();
               switch (char) {
+                case '\n':
+                  this.newLine();
+                  this.needIndent = true;
+                  break;
+                case '=':
+                  this.assignment();
+                  break;
+                case '|':
+                  this.pipe();
+                  break;
+                case ';':
+                  this.setToken(TokenType.Semicolon, ';');
+                  break;
                 case '/':
                   this.comment();
                   break;
@@ -322,9 +336,7 @@ class Tokenizer {
                   }
                   break;
               }
-              if (true) {
-                this.needLoc = false;
-              }
+              this.locEnd();
               break;
           }
           this.next();
@@ -340,6 +352,18 @@ class Tokenizer {
       this.handledTokens.push(this.token);
     }
   }
+  locStart() {
+    {
+      this.preCol = this.column;
+      this.preI = this.i;
+      this.needLoc = true;
+    }
+  }
+  locEnd() {
+    {
+      this.needLoc = false;
+    }
+  }
   getComment() {
     let value = '/';
     let nextC = this.code[this.i + 1];
@@ -356,11 +380,7 @@ class Tokenizer {
     this.getComment();
   }
   condExp() {
-    {
-      this.preCol = this.column;
-      this.preI = this.i;
-      this.needLoc = true;
-    }
+    this.locStart();
     let value = '';
     this.token = null;
     let char = this.code[this.i];
@@ -375,20 +395,14 @@ class Tokenizer {
     const trimmed = value.replace(/\/\/[\s\S]+/, '').trim();
     this.setToken(TokenType.Identifier, trimmed ? trimmed : true, 0);
     this.handledTokens.push(this.token);
-    {
-      this.needLoc = false;
-    }
+    this.locEnd();
     return this.token;
   }
   isEol(i) {
     return this.code[i] === '\n' || this.code[i] === '/';
   }
   jsExp() {
-    {
-      this.preCol = this.column;
-      this.preI = this.i;
-      this.needLoc = true;
-    }
+    this.locStart();
     this.token = null;
     let value = '';
     let char = this.code[this.i];
@@ -402,9 +416,7 @@ class Tokenizer {
     }
     this.setToken(TokenType.Identifier, value, 0);
     this.handledTokens.push(this.token);
-    {
-      this.needLoc = false;
-    }
+    this.locEnd();
     return this.token;
   }
   peekChar() {
@@ -592,7 +604,7 @@ class Tokenizer {
     const prevLen = this.dentStack[this.dentStack.length - 1];
     if (currLen > prevLen) {
       this.dentStack.push(currLen);
-      this.setToken(TokenType.Indent, currLen);
+      this.setToken(TokenType.Indent, currLen, 0);
       return indentHasLen;
     }
     if (currLen < prevLen) {
@@ -607,7 +619,7 @@ class Tokenizer {
         }
         this.dentStack.pop();
         if (!this.token) {
-          this.setToken(TokenType.Dedent, String(expLen));
+          this.setToken(TokenType.Dedent, String(expLen), 0);
         } else {
           this.waitingTokens.push({
             type: TokenType.Dedent,
@@ -1014,7 +1026,7 @@ var NodeType = function (NodeType) {
 let _initProto;
 class Compiler {
   static {
-    var _applyDecs$e = _slicedToArray(_applyDecs2311(this, [], [[NodeHook, 2, "parseProgram"], [[NodeHook, NodeLoc], 2, "parseComponentNode"], [[NodeHook, NodeLoc], 2, "parseElementNode"], [[NodeHook, NodeLoc], 2, "parseConditionalNode"], [[NodeHook, NodeLoc], 2, "parseLoopNode"], [NodeHook, 2, "parseProperty"], [[NodeHook, TokenLoc], 2, "parsePropertyKey"], [[NodeHook, TokenLoc], 2, "parseJsExp"], [[NodeHook, TokenLoc], 2, "parsePropertyValue"], [[NodeHook, TokenLoc], 2, "parseName"]]).e, 1);
+    var _applyDecs$e = _slicedToArray(_applyDecs2311(this, [], [[NodeHook, 2, "parseProgram"], [[NodeHook, NodeLoc], 2, "parseComponentNode"], [[NodeHook, NodeLoc], 2, "parseElementNode"], [[NodeHook, NodeLoc], 2, "parseConditionalNode"], [[NodeHook, NodeLoc], 2, "parseLoopNode"], [NodeHook, 2, "parseProperty"], [[NodeHook, TokenLoc], 2, "parsePropertyKey"], [[NodeHook, TokenLoc], 2, "parseJsExp"], [[NodeHook, TokenLoc], 2, "parsePropertyValue"], [[NodeHook, NodeLoc], 2, "parsePropertyInlineFragment"], [[NodeHook, TokenLoc], 2, "parseName"]]).e, 1);
     _initProto = _applyDecs$e[0];
   }
   errors = (_initProto(this), []);
@@ -1116,9 +1128,9 @@ class Compiler {
   parseComponentNode(node) {
     const name = this.parseName();
     this.tokenizer.nextToken();
-    const props = this.headerLineAndExtensions();
     node.type = NodeType.Component;
     node.componentName = name;
+    const props = this.headerLineAndExtensions();
     node.props = props;
     this.hooks.parseComponentNode?.propsAdded?.call(this, node);
     const children = this.handleChildren();
@@ -1136,9 +1148,9 @@ class Compiler {
     }
     const tagName = tagToken.value;
     this.tokenizer.nextToken();
-    const props = this.headerLineAndExtensions();
     node.type = NodeType.Element;
     node.tagName = tagName;
+    const props = this.headerLineAndExtensions();
     node.props = props;
     this.hooks.parseElementNode?.propsAdded?.call(this, node);
     const children = this.handleChildren();
@@ -1212,17 +1224,17 @@ class Compiler {
   }
   headerLineAndExtensions() {
     const props = [];
-    props.push(...this.attributeList());
-    if (this.tokenizer.token.type & TokenType.NewLine) {
-      this.tokenizer.nextToken();
-    }
-    while (this.tokenizer.token.type & TokenType.Pipe) {
-      this.tokenizer.nextToken();
+    do {
       props.push(...this.attributeList());
       if (this.tokenizer.token.type & TokenType.NewLine) {
         this.tokenizer.nextToken();
       }
-    }
+      if ((this.tokenizer.token.type & TokenType.Pipe) === 0) {
+        break;
+      } else {
+        this.tokenizer.nextToken();
+      }
+    } while (true);
     return props;
   }
   attributeList() {
@@ -1246,25 +1258,35 @@ class Compiler {
     const token = this.tokenizer.nextToken();
     if (token.value !== '=') {
       this.addError(ParseErrorCode.MISSING_ASSIGN, `属性 "${node.key.key}" 缺少 "=" 赋值符号`, node.key.loc ?? this.tokenizer.emptyLoc(), node);
-      node.loc.start = node.key.loc.start;
-      node.loc.end = node.key.loc.end;
-      node.loc.source = this.tokenizer.code.slice(node.loc.start.offset, node.loc.end.offset);
+      this.handleOnlyKeyLoc(node);
       return node;
     }
     const valueToken = this.tokenizer.nextToken();
+    if (valueToken.type & TokenType.NewLine) {
+      this.tokenizer.nextToken();
+      node.value = this.parsePropertyInlineFragment();
+      this.handleKeyValueLoc(node);
+      return node;
+    }
     if ((valueToken.type & ValueTokenType) === 0) {
       this.addError(ParseErrorCode.MISSING_PROP_ASSIGNMENT, `属性值不合法, "${valueToken.value}" 不合法`, valueToken.loc ?? this.tokenizer.emptyLoc(), node);
-      node.loc.start = node.key.loc.start;
-      node.loc.end = node.key.loc.end;
-      node.loc.source = this.tokenizer.code.slice(node.loc.start.offset, node.loc.end.offset);
+      this.handleOnlyKeyLoc(node);
       return node;
     }
     node.value = this.parsePropertyValue();
     this.tokenizer.nextToken();
+    this.handleKeyValueLoc(node);
+    return node;
+  }
+  handleOnlyKeyLoc(node) {
+    node.loc.start = node.key.loc.start;
+    node.loc.end = node.key.loc.end;
+    node.loc.source = this.tokenizer.code.slice(node.loc.start.offset, node.loc.end.offset);
+  }
+  handleKeyValueLoc(node) {
     node.loc.start = node.key.loc.start;
     node.loc.end = node.value.loc.end;
     node.loc.source = this.tokenizer.code.slice(node.loc.start.offset, node.loc.end.offset);
-    return node;
   }
   parsePropertyKey(node) {
     node.type = NodeType.PropertyKey;
@@ -1289,6 +1311,12 @@ class Compiler {
     node.value = value;
     return node;
   }
+  parsePropertyInlineFragment(node) {
+    const list = this.handleChildren();
+    node.type = NodeType.StaticValue;
+    node.value = list;
+    return node;
+  }
   parseName(node) {
     const _this$tokenizer$_hook7 = this.tokenizer._hook({}),
       _this$tokenizer$_hook8 = _slicedToArray(_this$tokenizer$_hook7, 2),
@@ -1512,6 +1540,9 @@ class Interpreter {
           }
           if (sort & NodeSort.TokenizerSwitcher) {
             const switcher = stack.peekByType(NodeSort.TokenizerSwitcher)?.node;
+            if (parent.resumeSnapshot) {
+              this.tokenizer.resume(parent.resumeSnapshot);
+            }
             this.tokenizer = switcher.tokenizer;
           }
           if (parent.__logicType === FakeType.ForItem) {
@@ -1606,7 +1637,7 @@ class Interpreter {
       } else {
         const valueIsMapKey = Reflect.has(data[Keys.Raw], value);
         const val = data[Keys.Raw][value];
-        if (typeof val === 'function') {
+        if (typeof val === 'function' || val instanceof InlineFragment) {
           _node = this.componentOrFragmentDeclaration(val, ctx);
         } else {
           const str = valueIsMapKey ? value : this.getFn(data, value);
@@ -1618,11 +1649,15 @@ class Interpreter {
       _node = this.createNode(value);
     }
     this.tokenizer.nextToken();
-    this.headerLine(_node);
-    this.extensionLines(_node);
+    this.headerLineAndExtensions(_node);
     this.onePropParsed = this.oneRealPropParsed;
     if (_node.__logicType & TokenizerSwitcherBit) {
       this.tokenizer = _node.tokenizer;
+      if (_node.fragmentSnapshot) {
+        this.tokenizer.resume(_node.fragmentSnapshot);
+        this.tokenizer.useDedentAsEof = true;
+        this.tokenizer.initIndentWhenUseDedentAsEof();
+      }
     }
     return _node;
   }
@@ -1704,7 +1739,7 @@ class Interpreter {
       _forNode$snapshot.isFirstToken;
       const snapshotForUpdate = _objectWithoutProperties(_forNode$snapshot, _excluded);
     let isFirstRender = true;
-    forNode.effect = new Effect(() => {
+    forNode.effect = new this.Effect(() => {
       let arr = arrSignal.get();
       arr[Keys.Iterator];
       const prevCtx = getPulling();
@@ -1875,7 +1910,7 @@ class Interpreter {
           }
         }
       };
-    });
+    }, ScheduleType.Render);
     return forNode.children[0] || forNode;
   }
   insertForItem(forNode, i, parentData, newChildren, before, snapshotForUpdate) {
@@ -1981,33 +2016,42 @@ class Interpreter {
         return this.setProp(node, key, value, hookI);
       }).get();
     } else if (typeof value === 'function') {
-      new Effect(() => {
+      new this.Effect(() => {
         const res = value(data);
         const dispose = this.setProp(node, key, res, hookI);
         return dispose;
-      });
+      }, ScheduleType.Render);
     } else if (valueIsMapKey) {
-      new Effect(() => {
+      new this.Effect(() => {
         const res = data[value];
         const dispose = this.setProp(node, key, res, hookI);
         return dispose;
-      });
+      }, ScheduleType.Render);
     } else {
       this.setProp(node, key, value, hookI);
     }
   }
   oneRealPropParsed = this.onePropParsed.bind(this);
   componentOrFragmentDeclaration(ComponentOrRender, ctx) {
-    let Component, render, child;
+    let Component, tokenizer, child, fragmentSnapshot, resumeSnapshot;
     const isCC = ComponentOrRender.prototype instanceof Store;
     if (isCC) {
       Component = ComponentOrRender;
       child = Component.new();
+      tokenizer = child.ui(true);
+    } else if (ComponentOrRender instanceof InlineFragment) {
+      const conf = ComponentOrRender;
+      child = deepSignal({}, getPulling(), true);
+      Object.setPrototypeOf(child, conf.data);
+      tokenizer = conf.tokenizer;
+      fragmentSnapshot = conf.snapshot;
+      resumeSnapshot = tokenizer.snapshot(['token', 'needIndent', 'isFirstToken', 'dentStack', 'isFirstToken', 'useDedentAsEof']);
     } else {
-      render = ComponentOrRender;
+      const render = ComponentOrRender;
       const boundStore = render.boundStore;
       child = deepSignal({}, getPulling(), true);
       Object.setPrototypeOf(child, boundStore);
+      tokenizer = render(true);
     }
     const node = {
       __logicType: isCC ? FakeType.Component : FakeType.Fragment,
@@ -2015,7 +2059,9 @@ class Interpreter {
       realBefore: null,
       realAfter: null,
       data: child,
-      tokenizer: render ? render(true) : child.ui(true)
+      tokenizer,
+      fragmentSnapshot,
+      resumeSnapshot
     };
     this.onePropParsed = createStoreOnePropParsed(child);
     node.realAfter = this.insertAfterAnchor('component-after');
@@ -2114,7 +2160,7 @@ class Interpreter {
     }
     ifNode.condition = signal;
     ifNode.realAfter = this.insertAfterAnchor(`${keyWord.value}-after`);
-    const ef = effect(({
+    const ef = this.effect(({
       val
     }) => {
       if (val) {
@@ -2135,7 +2181,9 @@ class Interpreter {
         }
       }
       ifNode.isFirstRender = false;
-    }, [signal]);
+    }, [signal], {
+      type: 'render'
+    });
     ifNode.effect = ef;
     return ifNode;
   }
@@ -2150,26 +2198,38 @@ class Interpreter {
       point = next;
     }
   }
-  extensionLines(_node) {
-    while (1) {
-      if ((this.tokenizer.token.type & TokenType.Pipe) === 0) {
-        return;
+  headerLineAndExtensions(_node) {
+    const tokenizer = this.tokenizer;
+    do {
+      const isComponent = _node.__logicType & TokenizerSwitcherBit;
+      let snapshot, dentLen;
+      const data = this.getData();
+      const unHandledKey = this.attributeList(_node, data);
+      if (isComponent) {
+        snapshot = tokenizer.snapshot(undefined, -1);
+        dentLen = tokenizer.dentStack[tokenizer.dentStack.length - 1];
       }
-      this.tokenizer.nextToken();
-      this.attributeList(_node);
-      if ((this.tokenizer.token.type & TokenType.NewLine) === 0) {
-        return;
+      tokenizer.nextToken();
+      if ((tokenizer.token.type & TokenType.Pipe) === 0) {
+        if (isComponent && tokenizer.token.type & TokenType.Indent) {
+          this.inlineFragment(_node, snapshot, data, unHandledKey);
+          tokenizer.skip(dentLen);
+          if ((tokenizer.token.type & TokenType.Pipe) === 0) {
+            break;
+          }
+        } else {
+          break;
+        }
       }
-      this.tokenizer.nextToken();
-    }
+      tokenizer.nextToken();
+    } while (true);
   }
-  headerLine(_node) {
-    this.attributeList(_node);
-    this.tokenizer.nextToken();
+  inlineFragment(_node, snapshot, data, key = 'children') {
+    const value = new InlineFragment(snapshot, data, key, this.tokenizer);
+    this.onePropParsed(data, _node, key, value, false, true);
   }
-  attributeList(_node) {
+  attributeList(_node, data) {
     let key, eq;
-    const data = this.getData();
     while ((this.tokenizer.token.type & TokenType.NewLine) === 0) {
       if (key == null) {
         key = this.tokenizer.token.value;
@@ -2217,10 +2277,15 @@ class Interpreter {
       }
       this.tokenizer.nextToken();
     }
+    return key;
   }
   config(opt) {
     Object.assign(this, opt);
     this.opt = opt;
+    if (opt.noopEffect) {
+      this.effect = noopEffect;
+      this.Effect = NoopEffect;
+    }
   }
   createNode(name) {
     return {
@@ -2270,6 +2335,8 @@ class Interpreter {
   setProp(node, key, value, hookI) {
     node.props[key] = value;
   }
+  Effect = Effect;
+  effect = effect$1;
 }
 function createStoreOnePropParsed(child) {
   const onePropParsed = (data, _, key, value, valueIsMapKey, isFn, hookI) => {
@@ -2294,6 +2361,15 @@ function createStoreOnePropParsed(child) {
   };
   return onePropParsed;
 }
+class InlineFragment {
+  [Keys.ProxyFreeObject] = true;
+  constructor(snapshot, data, key, tokenizer) {
+    this.snapshot = snapshot;
+    this.data = data;
+    this.key = key;
+    this.tokenizer = tokenizer;
+  }
+}
 
 function bobe(fragments, ...values) {
   const ui = function ui(isSub) {
@@ -2340,5 +2416,29 @@ const context = name => {
   return context;
 };
 
-export { Compiler, NodeType, ParseSyntaxError, Tokenizer, bobe, context, customRender };
+const depTokenizer = new Tokenizer(() => '', false);
+const effect = (callback, depOrOpt, opt) => {
+  const isArray = Array.isArray(depOrOpt);
+  const isSingleDep = isDep(depOrOpt);
+  const deps = isArray ? depOrOpt : isSingleDep ? [depOrOpt] : [];
+  const option = isArray || isSingleDep ? opt : depOrOpt;
+  const newDeps = [];
+  for (let i = 0; i < deps.length; i++) {
+    const dep = deps[i];
+    if (typeof dep === 'string') {
+      depTokenizer.code = dep.trim() + '\n';
+      let exp;
+      while (depTokenizer.i < depTokenizer.code.length) {
+        exp = depTokenizer.jsExp().value;
+        depTokenizer.nextToken();
+        newDeps.push(new Function('data', `let v;with(data){v=${exp};}return v;`).bind(undefined, Store.Current));
+      }
+    } else {
+      newDeps.push(dep);
+    }
+  }
+  return effect$1(callback, newDeps, option);
+};
+
+export { Compiler, NodeType, ParseSyntaxError, Tokenizer, bobe, context, customRender, effect };
 //# sourceMappingURL=bobe.compiler.esm.js.map