bobe 0.0.11 → 0.0.13

package/dist/bobe.esm.js

@@ -1,4 +1,4 @@
-import { Store, Keys, effect, shareSignal, $ } from 'aoye';
+import { Store, getPulling, setPulling, Keys, effect, shareSignal, $, runWithPulling } from 'aoye';
 export * from 'aoye';
 import { BaseEvent, Queue, isNum } from 'bobe-shared';
 
@@ -15,19 +15,101 @@ var TokenType = /* @__PURE__ */ ((TokenType2) => {
 })(TokenType || {});
 var LogicType = /* @__PURE__ */ ((LogicType2) => {
   LogicType2[LogicType2["If"] = 1] = "If";
-  LogicType2[LogicType2["ElseIf"] = 2] = "ElseIf";
+  LogicType2[LogicType2["Fail"] = 2] = "Fail";
   LogicType2[LogicType2["Else"] = 4] = "Else";
   LogicType2[LogicType2["For"] = 8] = "For";
   LogicType2[LogicType2["Component"] = 16] = "Component";
   LogicType2[LogicType2["Fragment"] = 32] = "Fragment";
   LogicType2[LogicType2["Root"] = 64] = "Root";
+  LogicType2[LogicType2["Real"] = 128] = "Real";
   return LogicType2;
 })(LogicType || {});
+const Logical = 1 /* If */ | 2 /* Fail */ | 4 /* Else */ | 8 /* For */;
+const CondType = 1 /* If */ | 2 /* Fail */ | 4 /* Else */;
+var NodeType = /* @__PURE__ */ ((NodeType2) => {
+  NodeType2[NodeType2["Logic"] = Logical] = "Logic";
+  NodeType2[NodeType2["Real"] = 128 /* Real */] = "Real";
+  NodeType2[NodeType2["Component"] = 16 /* Component */] = "Component";
+  return NodeType2;
+})(NodeType || {});
 var TerpEvt = /* @__PURE__ */ ((TerpEvt2) => {
   TerpEvt2["AllAttrGot"] = "all-attr-got";
   TerpEvt2["HandledComponentNode"] = "handled-component-node";
   return TerpEvt2;
 })(TerpEvt || {});
+const IsAnchor = /* @__PURE__ */ Symbol("is-anchor");
+
+class TypedStack {
+  constructor() {
+    this.top = null;
+    // 存储每种类型最近一次出现的包装单元引用
+    // 使用 Record 来动态支持不同的类型标签
+    this.lastNodes = {};
+    this.length = 0;
+  }
+  /**
+   * @param rawNode 原始节点数据
+   * @param type 节点类型
+   */
+  push(rawNode, type) {
+    var _a;
+    const newNode = {
+      data: rawNode,
+      type,
+      prev: this.top,
+      prevSameType: (_a = this.lastNodes[type]) != null ? _a : null
+    };
+    this.top = newNode;
+    this.length++;
+    this.lastNodes[type] = newNode;
+  }
+  /**
+   * 出栈操作
+   * @returns 原始节点数据或 null
+   */
+  pop() {
+    if (!this.top) return null;
+    const popped = this.top;
+    this.lastNodes[popped.type] = popped.prevSameType;
+    this.top = popped.prev;
+    this.length--;
+    return popped.data;
+  }
+  /**
+   * O(1) 获取栈顶节点的前一个同类型节点
+   */
+  getPrevSameType() {
+    if (!this.top || !this.top.prevSameType) {
+      return null;
+    }
+    return this.top.prevSameType.data;
+  }
+  findPrevSameType(cb) {
+    if (!this.top) {
+      return null;
+    }
+    let point = this.top.prevSameType;
+    while (point) {
+      if (cb(point.data)) {
+        return point.data;
+      }
+      point = point.prevSameType;
+    }
+    return null;
+  }
+  /**
+   * 获取当前栈顶的类型
+   */
+  get peekType() {
+    return this.top ? this.top.type : null;
+  }
+  /**
+   * 获取栈顶元素
+   */
+  peek() {
+    return this.top.data;
+  }
+}
 
 var __defProp$1 = Object.defineProperty;
 var __defProps$1 = Object.defineProperties;
@@ -77,61 +159,96 @@ class Interpreter {
       return [hookType, value];
     };
   }
-  // /** program 要挂载的父节点位置 */
-  // root: any;
-  // /** program 挂载的前置节点 */
-  // anchor: any;
+  isLogicNode(node) {
+    return node && node.__logicType & Logical;
+  }
   program(root, before) {
+    var _a;
     const componentNode = {
       __logicType: LogicType.Component,
       realParent: root,
       store: new Store()
     };
     this.tokenizer.consume();
-    let prevSibling = null;
-    let current;
-    const stack = [{ node: root, prev: prevSibling }];
+    const stack = new TypedStack();
+    stack.push({ node: root, prev: null }, NodeType.Real);
+    const ctx = {
+      realParent: root,
+      prevSibling: before,
+      current: null,
+      stack,
+      before
+    };
+    const rootPulling = getPulling();
     while (1) {
       if (this.tokenizer.isEof()) {
-        this.handleInsert(root, current, prevSibling, componentNode);
+        if (!ctx.prevSibling) ctx.prevSibling = before;
+        this.handleInsert(root, ctx.current, ctx.prevSibling, componentNode);
         break;
       }
       const token = this.tokenizer.token;
       if (token.type & TokenType.Indent) {
         this.tokenizer.consume();
-        stack.push({
-          node: current,
-          prev: prevSibling
-        });
-        current = this.declaration({ stack, prevSibling });
-        prevSibling = null;
-        continue;
-      }
-      if (current) {
-        if (stack.length > 1) {
-          const { node: parent } = stack[stack.length - 1];
-          this.handleInsert(parent, current, prevSibling);
+        const isLogicNode = this.isLogicNode(ctx.current);
+        stack.push(
+          {
+            node: ctx.current,
+            prev: ctx.prevSibling
+          },
+          ctx.current.__logicType ? isLogicNode ? NodeType.Logic : NodeType.Component : NodeType.Real
+        );
+        if (ctx.current.__logicType) {
+          if (isLogicNode) {
+            setPulling(ctx.current.effect.ins);
+          }
         } else {
-          if (!prevSibling) {
-            prevSibling = before;
+          if (ctx.current) {
+            ctx.realParent = ctx.current;
           }
-          this.handleInsert(root, current, prevSibling, componentNode);
+          ctx.prevSibling = null;
         }
+        ctx.current = this.declaration(ctx);
+        continue;
+      }
+      if (ctx.current) {
+        if (stack.length === 1 && !ctx.prevSibling) {
+          ctx.prevSibling = before;
+        }
+        this.handleInsert(ctx.realParent, ctx.current, ctx.prevSibling);
       }
       if (this.tokenizer.token.type & TokenType.Dedent) {
         this.tokenizer.consume();
-        const { node: parent, prev } = stack.pop();
-        prevSibling = prev;
-        current = parent;
+        const { node: parent, prev } = stack.peek();
+        if (!parent.__logicType) {
+          const prevSameType = stack.getPrevSameType();
+          ctx.realParent = (prevSameType == null ? void 0 : prevSameType.node) || root;
+        } else {
+          if (this.isLogicNode(parent)) {
+            const parentLogic = (_a = stack.getPrevSameType()) == null ? void 0 : _a.node;
+            if (parentLogic) {
+              setPulling(parentLogic.effect.ins);
+            } else {
+              setPulling(rootPulling);
+            }
+          }
+        }
+        stack.pop();
+        ctx.prevSibling = prev;
+        ctx.current = parent;
       } else {
-        prevSibling = current;
-        current = this.declaration({ stack, prevSibling });
+        ctx.prevSibling = ctx.current || ctx.prevSibling;
+        ctx.current = this.declaration(ctx);
       }
     }
-    componentNode.lastInserted = this.lastInserted;
-    this.lastInserted = null;
     return componentNode;
   }
+  insertAfterAnchor(ctx) {
+    const { realParent, prevSibling, stack, before } = ctx;
+    const afterAnchor = this.createAnchor();
+    ctx.prevSibling = stack.length === 1 && !prevSibling ? before : prevSibling;
+    this.handleInsert(realParent, afterAnchor, prevSibling);
+    return afterAnchor;
+  }
   /** 处理
    *                    是逻辑                               是普通
    * 父节点       将子节点加入 directList         调用 insert 方法挨个插入子节点
@@ -143,25 +260,14 @@ class Interpreter {
       if (!prev || !prev.__logicType) {
         this.insertAfter(parent, child, prev);
       } else {
-        const before = prev.lastInserted;
+        const before = prev.realAfter;
         this.insertAfter(parent, child, before);
-        prev.realAfter = child;
       }
     } else {
       const childCmp = child;
       childCmp.realParent = parent;
-      if (!prev) {
-        const anchor = this.createAnchor();
-        this.insertAfter(parent, anchor, prev);
-        this.insertAfter(parent, child, anchor);
-        childCmp.realBefore = anchor;
-      } else if (prev.__logicType) {
-        const before = prev.lastInserted;
-        const anchor = this.createAnchor();
-        this.insertAfter(parent, anchor, before);
-        this.insertAfter(parent, child, anchor);
-        childCmp.realBefore = anchor;
-        prev.realAfter = anchor;
+      if (prev == null ? void 0 : prev.__logicType) {
+        childCmp.realBefore = prev.realAfter;
       } else {
         childCmp.realBefore = prev;
       }
@@ -188,8 +294,8 @@ class Interpreter {
   declaration(ctx) {
     const [hookType, value] = this._hook({});
     let _node;
-    if (value === "if") {
-      return this.ifDeclaration();
+    if (value === "if" || value === "else" || value === "fail") {
+      return this.condDeclaration(ctx);
     } else if (hookType) {
       if (hookType === "static") {
         if (typeof value === "function" && value.prototype instanceof Store) {
@@ -263,37 +369,127 @@ class Interpreter {
         child[Keys.Raw][key] = value;
       }
     };
+    const afterAnchor = this.insertAfterAnchor(ctx);
+    const { realParent, prevSibling } = ctx;
     tap.once(TerpEvt.AllAttrGot, () => {
-      const parent = ctx.stack[ctx.stack.length - 1].node;
-      const prev = ctx.prevSibling;
+      const parent = realParent;
+      const prev = prevSibling;
       this.onePropParsed = prevOnePropParsed;
       const componentNode = child["ui"](this.opt, { data: child }, parent, prev);
+      componentNode.realAfter = afterAnchor;
       tap.emit(TerpEvt.HandledComponentNode, componentNode);
     });
     return { __logicType: LogicType.Component };
   }
-  ifDeclaration() {
-    this.tokenizer.consume();
-    const [isHook, value] = this._hook({});
+  // TODO: 优化代码逻辑，拆分 if elseif else
+  condDeclaration(ctx) {
+    const { prevSibling } = ctx;
+    const snapbackUp = this.tokenizer.snapshot();
+    const keyWord = this.tokenizer.consume();
+    const noSelfCond = this.tokenizer.token.type === TokenType.NewLine;
+    const [hookType, value] = this._hook({});
+    const isElse = keyWord.value === "else";
+    const isIf = keyWord.value === "if";
+    const preIsCond = (prevSibling == null ? void 0 : prevSibling.__logicType) & CondType;
+    const needCalcWithPrevIf = isElse && preIsCond;
     const ifNode = {
-      __logicType: LogicType.If,
-      condition: value,
+      __logicType: isElse ? LogicType.Else : isIf ? LogicType.If : LogicType.Fail,
+      snapshot: noSelfCond ? snapbackUp : this.tokenizer.snapshot(),
+      condition: null,
       realParent: null,
-      snapshot: this.tokenizer.snapshot(),
+      preCond: preIsCond ? prevSibling : null,
       isFirstRender: true,
-      watcher: null,
-      anchor: null
+      effect: null
     };
-    ifNode.watcher = effect(
+    let signal;
+    if (noSelfCond) {
+      if (isElse) {
+        signal = $(() => {
+          let point = ifNode.preCond;
+          while (point) {
+            if (point.condition.v) {
+              return false;
+            }
+            if (point.__logicType === LogicType.If) {
+              break;
+            }
+            point = point.preCond;
+          }
+          return true;
+        });
+      } else {
+        signal = $(() => {
+          let point = ifNode.preCond;
+          while (point) {
+            if (point.condition.v) {
+              return false;
+            }
+            point = point.preCond;
+          }
+          return true;
+        });
+      }
+    } else {
+      const valueIsMapKey = Reflect.has(this.data[Keys.Raw], value);
+      if (valueIsMapKey && !needCalcWithPrevIf) {
+        runWithPulling(() => this.data[value], null);
+        const { cells } = this.data[Keys.Meta];
+        signal = cells.get(value);
+      } else {
+        const fn = new Function("data", `let v;with(data){v=${value}};return v;`).bind(void 0, this.data);
+        if (needCalcWithPrevIf) {
+          signal = $(() => {
+            let point = ifNode.preCond;
+            while (point) {
+              if (point.condition.v) {
+                return false;
+              }
+              if (point.__logicType === LogicType.If) {
+                break;
+              }
+              point = point.preCond;
+            }
+            return fn();
+          });
+        } else {
+          signal = $(fn);
+        }
+      }
+    }
+    ifNode.condition = signal;
+    ifNode.realAfter = this.insertAfterAnchor(ctx);
+    ifNode.effect = effect(
       ({ val }) => {
         if (val) {
-          this.tokenizer.consume();
-          this.tokenizer.consume();
+          if (ifNode.isFirstRender) {
+            if (!noSelfCond) {
+              this.tokenizer.consume();
+            }
+            this.tokenizer.consume();
+          } else {
+            this.tokenizer.resume(ifNode.snapshot);
+            this.program(ifNode.realParent, ifNode.realBefore);
+          }
         } else {
-          this.tokenizer.skip();
+          if (ifNode.isFirstRender) {
+            if (noSelfCond) {
+              this.tokenizer.i = this.tokenizer.i - 1;
+              this.tokenizer.needIndent = false;
+            }
+            this.tokenizer.skip();
+          } else {
+            const { realBefore, realAfter, realParent } = ifNode;
+            let point = realBefore ? this.nextSib(realBefore) : this.kid(realParent);
+            while (point !== realAfter) {
+              const next = this.nextSib(point);
+              this.remove(point, realParent, realBefore);
+              point = next;
+            }
+          }
         }
+        ifNode.isFirstRender = false;
       },
-      [value]
+      [signal]
     );
     return ifNode;
   }
@@ -371,6 +567,14 @@ class Interpreter {
   nextSib(node) {
     return node.nextSibling;
   }
+  kid(node) {
+    return node.firstChild;
+  }
+  _createAnchor() {
+    const anchor = this.createAnchor();
+    anchor[IsAnchor] = true;
+    return anchor;
+  }
   createAnchor() {
     return {
       name: "anchor",
@@ -378,7 +582,6 @@ class Interpreter {
     };
   }
   insertAfter(parent, node, prev) {
-    this.lastInserted = node;
     return this.defaultInsert(parent, node, prev);
   }
   defaultInsert(parent, node, prev) {
@@ -387,14 +590,16 @@ class Interpreter {
       prev.nextSibling = node;
       node.nextSibling = next;
     } else {
+      const next = parent.firstChild;
       parent.firstChild = node;
+      node.nextSibling = next;
     }
   }
-  remove(parent, node, prevSibling) {
-    return this.defaultRemove(parent, node, prevSibling);
+  remove(node, parent, prev) {
+    return this.defaultRemove(node, parent, prev);
   }
   // TODO: 默认改成 prevItem
-  defaultRemove(parent, node, prevSibling) {
+  defaultRemove(node, parent, prevSibling) {
     const next = node.nextSibling;
     if (prevSibling) {
       prevSibling.nextSibling = next;
@@ -467,7 +672,7 @@ const _Tokenizer = class _Tokenizer {
     };
   }
   skip() {
-    const dentLen = this.dentStack[this.dentStack.length - 1];
+    const logicDentLen = this.dentStack[this.dentStack.length - 1];
     let needIndent = false;
     let skipFragment = ``;
     this.token = void 0;
@@ -488,7 +693,7 @@ const _Tokenizer = class _Tokenizer {
       const { value, isEmptyLine } = this.getDentValue();
       const currLen = value.length;
       if (isEmptyLine) continue;
-      if (value.length > dentLen) {
+      if (currLen > logicDentLen) {
         skipFragment += value;
       } else {
         for (let i = this.dentStack.length - 1; i >= 0; i--) {
@@ -497,6 +702,9 @@ const _Tokenizer = class _Tokenizer {
           if (currLen > expLen) {
             throw SyntaxError(`\u7F29\u8FDB\u9519\u8BEF\uFF0C\u7F29\u8FDB\u957F\u5EA6\u4E0D\u5339\u914D`);
           }
+          if (this.shorterThanBaseDentEof()) {
+            break;
+          }
           this.dentStack.pop();
           if (!this.token) {
             this.setToken(TokenType.Dedent, String(expLen));
@@ -761,12 +969,15 @@ ${_Tokenizer.EofId}`;
       return indentHasLen;
     }
     if (currLen < prevLen) {
-      for (let i = this.dentStack.length - 2; i >= 0; i--) {
+      for (let i = this.dentStack.length; i--; ) {
         const expLen = this.dentStack[i];
-        const prevExpLen = this.dentStack[i + 1];
-        if (currLen > expLen && currLen < prevExpLen) {
+        if (currLen === expLen) break;
+        if (currLen > expLen) {
           throw SyntaxError("\u7F29\u8FDB\u5927\u5C0F\u4E0D\u7EDF\u4E00");
         }
+        if (this.shorterThanBaseDentEof()) {
+          return;
+        }
         this.dentStack.pop();
         if (!this.token) {
           this.setToken(TokenType.Dedent, String(expLen));
@@ -777,14 +988,26 @@ ${_Tokenizer.EofId}`;
             value: String(expLen)
           });
         }
-        if (currLen === expLen) {
-          break;
-        }
       }
       return indentHasLen;
     }
     return indentHasLen;
   }
+  shorterThanBaseDentEof() {
+    const yes = this.dentStack.length === 1;
+    if (yes) {
+      if (!this.token) {
+        this.setToken(TokenType.Identifier, _Tokenizer.EofId);
+      } else {
+        this.waitingTokens.push({
+          type: TokenType.Identifier,
+          typeName: TokenType[TokenType.Identifier],
+          value: _Tokenizer.EofId
+        });
+      }
+    }
+    return yes;
+  }
   identifier(char) {
     let value = char;
     let nextC;