bobe 0.0.11 → 0.0.12

package/dist/index.umd.js

@@ -23,13 +23,94 @@
     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 /* ElseIf */ | 4 /* Else */ | 8 /* For */;
+  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;
@@ -79,61 +160,94 @@
         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 aoye.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 = aoye.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;
+          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) {
+              aoye.setPulling(ctx.current.effect.ins);
+            }
+          } else {
+            ctx.realParent = ctx.current;
+            ctx.prevSibling = null;
+          }
+          ctx.current = this.declaration(ctx);
           continue;
         }
-        if (current) {
-          if (stack.length > 1) {
-            const { node: parent } = stack[stack.length - 1];
-            this.handleInsert(parent, current, prevSibling);
-          } else {
-            if (!prevSibling) {
-              prevSibling = before;
-            }
-            this.handleInsert(root, current, prevSibling, componentNode);
+        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;
+          } else {
+            if (this.isLogicNode(parent)) {
+              const parentLogic = (_a = stack.getPrevSameType()) == null ? void 0 : _a.node;
+              if (parentLogic) {
+                aoye.setPulling(parentLogic.effect.ins);
+              } else {
+                aoye.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 方法挨个插入子节点
@@ -145,25 +259,14 @@
         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.__logicType) {
+          childCmp.realBefore = prev.realAfter;
         } else {
           childCmp.realBefore = prev;
         }
@@ -191,7 +294,7 @@
       const [hookType, value] = this._hook({});
       let _node;
       if (value === "if") {
-        return this.ifDeclaration();
+        return this.ifDeclaration(ctx);
       } else if (hookType) {
         if (hookType === "static") {
           if (typeof value === "function" && value.prototype instanceof aoye.Store) {
@@ -265,37 +368,66 @@
           child[aoye.Keys.Raw][key] = value;
         }
       };
+      const afterAnchor = this.insertAfterAnchor(ctx);
       tap.once(TerpEvt.AllAttrGot, () => {
-        const parent = ctx.stack[ctx.stack.length - 1].node;
+        const parent = ctx.realParent;
         const prev = ctx.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() {
+    ifDeclaration(ctx) {
       this.tokenizer.consume();
-      const [isHook, value] = this._hook({});
+      const [hookType, value] = this._hook({});
       const ifNode = {
         __logicType: LogicType.If,
-        condition: value,
-        realParent: null,
         snapshot: this.tokenizer.snapshot(),
+        condition: null,
+        realParent: null,
         isFirstRender: true,
-        watcher: null,
-        anchor: null
+        effect: null
       };
-      ifNode.watcher = aoye.effect(
+      const valueIsMapKey = Reflect.has(this.data[aoye.Keys.Raw], value);
+      let signal;
+      if (valueIsMapKey) {
+        aoye.runWithPulling(() => this.data[value], null);
+        const { cells } = this.data[aoye.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);
+        signal = aoye.$(fn);
+      }
+      ifNode.condition = signal;
+      ifNode.realAfter = this.insertAfterAnchor(ctx);
+      ifNode.effect = aoye.effect(
         ({ val }) => {
           if (val) {
-            this.tokenizer.consume();
-            this.tokenizer.consume();
+            if (ifNode.isFirstRender) {
+              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) {
+              this.tokenizer.skip();
+            } else {
+              const { realBefore, realAfter, realParent } = ifNode;
+              let point = this.nextSib(realBefore);
+              while (point !== realAfter) {
+                const next = this.nextSib(point);
+                this.remove(point, realParent, realBefore);
+                point = next;
+              }
+            }
           }
+          ifNode.isFirstRender = false;
         },
-        [value]
+        [signal]
       );
       return ifNode;
     }
@@ -373,6 +505,11 @@
     nextSib(node) {
       return node.nextSibling;
     }
+    _createAnchor() {
+      const anchor = this.createAnchor();
+      anchor[IsAnchor] = true;
+      return anchor;
+    }
     createAnchor() {
       return {
         name: "anchor",
@@ -380,7 +517,6 @@
       };
     }
     insertAfter(parent, node, prev) {
-      this.lastInserted = node;
       return this.defaultInsert(parent, node, prev);
     }
     defaultInsert(parent, node, prev) {
@@ -392,11 +528,11 @@
         parent.firstChild = node;
       }
     }
-    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;
@@ -469,7 +605,7 @@
       };
     }
     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;
@@ -490,7 +626,7 @@
         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--) {
@@ -499,6 +635,9 @@
             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));
@@ -763,12 +902,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));
@@ -779,14 +921,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;