bobe 0.0.60 → 0.0.62

package/dist/bobe.esm.js

@@ -1,5 +1,5 @@
-import { Queue, isNum, matchIdStart2, matchId, escapeMap, pickInPlace, jsVarRegexp, date32 } from 'bobe-shared';
-import { Signal, Computed, Keys, isStore, getPulling, setPulling, deepSignal, toRaw, ScheduleType, runWithPulling, Scope, Store, noopEffect, NoopEffect, Effect, effect as effect$1, shareSignal, flushMicroEffectManual } from 'aoye';
+import { Queue, isNum, matchIdStart2, matchId, escapeMap, pickInPlace, jsVarRegexp, date32, hasOwn } from 'bobe-shared';
+import { Signal, Computed, Keys, isStore, getPulling, setPulling, runWithPulling, getProxyHasKey, deepSignal, Scope, backupSignal, toRaw, ScheduleType, Store, noopEffect, NoopEffect, Effect, effect as effect$1, shareSignal, flushMicroEffectManual } from 'aoye';
 export { Store } from 'aoye';
 
 let TokenType = function (TokenType) {
@@ -33,15 +33,15 @@ let FakeType = function (FakeType) {
   FakeType[FakeType["ForItem"] = 64] = "ForItem";
   FakeType[FakeType["Context"] = 128] = "Context";
   FakeType[FakeType["DynamicText"] = 256] = "DynamicText";
+  FakeType[FakeType["Tp"] = 512] = "Tp";
   return FakeType;
 }({});
 const CondBit = FakeType.If | FakeType.Fail | FakeType.Else;
-const LogicalBit = FakeType.If | FakeType.Fail | FakeType.Else | FakeType.For | FakeType.ForItem;
 const CtxProviderBit = FakeType.If | FakeType.Fail | FakeType.Else | FakeType.For | FakeType.ForItem | FakeType.Component | FakeType.Fragment | FakeType.DynamicText;
-const ContextBit = FakeType.If | FakeType.Fail | FakeType.Else | FakeType.ForItem | FakeType.Context;
+const ContextBit = FakeType.If | FakeType.Fail | FakeType.Else | FakeType.ForItem | FakeType.Context | FakeType.Tp;
 const TokenizerSwitcherBit = FakeType.Component | FakeType.Fragment;
 let NodeSort = function (NodeSort) {
-  NodeSort[NodeSort["Logic"] = 1] = "Logic";
+  NodeSort[NodeSort["EffectNode"] = 1] = "EffectNode";
   NodeSort[NodeSort["Real"] = 2] = "Real";
   NodeSort[NodeSort["Component"] = 4] = "Component";
   NodeSort[NodeSort["CtxProvider"] = 8] = "CtxProvider";
@@ -54,6 +54,7 @@ let NodeSort = function (NodeSort) {
   TerpEvt["HandledComponentNode"] = "handled-component-node";
   return TerpEvt;
 })({});
+const FakeNode = Symbol('fake-node');
 let ParseErrorCode = function (ParseErrorCode) {
   ParseErrorCode[ParseErrorCode["UNCLOSED_BRACE"] = 9001] = "UNCLOSED_BRACE";
   ParseErrorCode[ParseErrorCode["UNCLOSED_STRING"] = 9002] = "UNCLOSED_STRING";
@@ -1433,7 +1434,7 @@ const SAFE_HANDLER = {
   has: () => true,
   get: (t, k) => {
     if (typeof k === 'symbol') return t[k];
-    return k in t ? t[k] : undefined;
+    return t[k];
   }
 };
 const safe = data => new Proxy(data, SAFE_HANDLER);
@@ -1448,9 +1449,6 @@ class Interpreter {
   constructor(tokenizer) {
     this.tokenizer = tokenizer;
   }
-  isLogicNode(node) {
-    return node && node.__logicType & LogicalBit;
-  }
   rootComponent = null;
   program(root, componentNode, before, ctxProvider) {
     this.rootComponent = componentNode;
@@ -1469,7 +1467,7 @@ class Interpreter {
       stack.push({
         node: ctxProvider,
         prev: null
-      }, (ctxProvider.__logicType & LogicalBit ? NodeSort.Logic : 0) | NodeSort.CtxProvider);
+      }, (ctxProvider.__logicType && ctxProvider.effect ? NodeSort.EffectNode : 0) | NodeSort.CtxProvider);
     }
     const rootLen = stack.length;
     const ctx = this.ctx = {
@@ -1492,18 +1490,24 @@ class Interpreter {
       const token = this.tokenizer.token;
       if (token.type & TokenType.Indent) {
         this.tokenizer.nextToken();
-        const isLogicNode = this.isLogicNode(ctx.current);
+        const isEffectNode = ctx.current && ctx.current.__logicType && ctx.current.effect;
         stack.push({
           node: ctx.current,
           prev: ctx.prevSibling
-        }, !ctx.current.__logicType ? NodeSort.Real : (ctx.current.__logicType & LogicalBit ? NodeSort.Logic : 0) | (ctx.current.__logicType & TokenizerSwitcherBit ? NodeSort.TokenizerSwitcher : 0) | (ctx.current.__logicType & ContextBit ? NodeSort.Context : 0) | (ctx.current.__logicType === FakeType.Component ? NodeSort.Component : 0) | (ctx.current.__logicType & CtxProviderBit ? NodeSort.CtxProvider : 0));
+        }, !ctx.current.__logicType ? NodeSort.Real : (isEffectNode ? NodeSort.EffectNode : 0) | (ctx.current.__logicType & TokenizerSwitcherBit ? NodeSort.TokenizerSwitcher : 0) | (ctx.current.__logicType & ContextBit ? NodeSort.Context : 0) | (ctx.current.__logicType === FakeType.Component ? NodeSort.Component : 0) | (ctx.current.__logicType === FakeType.Tp ? NodeSort.Real : 0) | (ctx.current.__logicType & CtxProviderBit ? NodeSort.CtxProvider : 0));
         if (ctx.current.__logicType) {
           this.beforeLogicIndent?.(ctx.current);
-          if (isLogicNode) {
+          if (isEffectNode) {
             setPulling(ctx.current.effect);
             if (ctx.current.__logicType & FakeType.ForItem) {
               ctx.prevSibling = ctx.current.realBefore;
             }
+            if (ctx.current.__logicType & FakeType.Tp) {
+              runWithPulling(() => {
+                ctx.realParent = ctx.current.tpData.node;
+              }, null);
+              ctx.prevSibling = ctx.current.contentBefore;
+            }
           }
         } else {
           if (ctx.current) {
@@ -1537,16 +1541,24 @@ class Interpreter {
           sort = _stack$pop2[1];
         if (!parent.__logicType) {
           const prevSameType = stack.peekByType(NodeSort.Real);
-          ctx.realParent = prevSameType?.node || root;
+          const sameNode = prevSameType?.node;
+          if (sameNode) {
+            ctx.realParent = sameNode.__logicType === FakeType.Tp ? runWithPulling(() => sameNode.tpData.node, null) : sameNode;
+          } else {
+            ctx.realParent = root;
+          }
         } else {
-          if (sort & NodeSort.Logic) {
-            const parentLogic = stack.peekByType(NodeSort.Logic)?.node;
+          if (sort & NodeSort.EffectNode) {
+            const parentLogic = stack.peekByType(NodeSort.EffectNode)?.node;
             if (parentLogic) {
               setPulling(parentLogic.effect);
             } else {
               setPulling(rootPulling);
             }
           }
+          if (parent.__logicType === FakeType.Tp) {
+            ctx.realParent = parent.realParent;
+          }
           if (sort & NodeSort.TokenizerSwitcher) {
             const switcher = stack.peekByType(NodeSort.TokenizerSwitcher)?.node;
             if (parent.resumeSnapshot) {
@@ -1583,13 +1595,17 @@ class Interpreter {
     }
     return componentNode;
   }
-  insertAnchor(name = 'anchor', isBefore = false) {
+  insertAnchor(node, name = 'anchor', isBefore = false) {
     const _this$ctx = this.ctx,
       realParent = _this$ctx.realParent,
       prevSibling = _this$ctx.prevSibling,
       stack = _this$ctx.stack,
       before = _this$ctx.before;
+      _this$ctx.current;
     const afterAnchor = this.createAnchor(name, isBefore);
+    if (!isBefore) {
+      this.anchorRefBack(afterAnchor, node);
+    }
     this.ctx.prevSibling = stack.length === 2 && !prevSibling ? before : prevSibling;
     this.handleInsert(realParent, afterAnchor, prevSibling);
     return afterAnchor;
@@ -1634,6 +1650,8 @@ class Interpreter {
       return this.condDeclaration(ctx);
     } else if (value === 'context') {
       _node = this.createContextNode();
+    } else if (value === 'tp') {
+      return this.createTpNode();
     } else if (value === 'for') {
       return this.forDeclaration();
     } else if (hookType) {
@@ -1665,7 +1683,7 @@ class Interpreter {
     return _node;
   }
   dynamicDeclaration(pData, value, ctx) {
-    const valueIsMapKey = Reflect.has(pData[Keys.Raw], value);
+    const valueIsMapKey = Boolean(getProxyHasKey(pData, value));
     let node = {
       __logicType: null,
       realParent: null,
@@ -1677,7 +1695,7 @@ class Interpreter {
       parentDataProvider: ctx.stack.peekByType(NodeSort.CtxProvider)?.node
     };
     let isUpdate = false;
-    node.realAfter = this.insertAnchor(`dynamic-after`);
+    node.realAfter = this.insertAnchor(node, `dynamic-after`);
     node.effect = this.effect(({
       old,
       val
@@ -1749,10 +1767,110 @@ class Interpreter {
           this.removeLogicNode(node);
         }
       };
-    }, [() => {
-      const val = valueIsMapKey ? pData[value] : this.getFn(pData, value)();
-      return val;
-    }], {
+    }, [valueIsMapKey ? () => pData[value] : this.getFn(pData, value)], {
+      type: 'render'
+    });
+    return node;
+  }
+  createTpNode() {
+    const child = deepSignal({}, getPulling());
+    const node = {
+      __logicType: FakeType.Tp,
+      data: this.getData(),
+      realParent: null,
+      realBefore: null,
+      realAfter: null,
+      contentBefore: null,
+      contentAfter: null,
+      effect: null,
+      snapshot: null,
+      tpData: child,
+      owner: this.ctx.stack.peekByType(NodeSort.TokenizerSwitcher)?.node
+    };
+    this.onePropParsed = createStoreOnePropParsed(child);
+    this.tokenizer.nextToken();
+    this.headerLineAndExtensions(node);
+    this.onePropParsed = this.oneRealPropParsed;
+    node.realAfter = this.insertAnchor(node, 'tp-after');
+    const before = node.contentBefore = this.createAnchor('tp-content-before', true);
+    const after = node.contentAfter = this.createAnchor('tp-content-after', true);
+    let firstRender = true;
+    let scope = new Scope(() => {});
+    scope.scope = null;
+    runWithPulling(() => {
+      scope.get();
+    }, null);
+    node.effect = scope;
+    this.effect(({
+      old: oldDom,
+      val: dom
+    }) => {
+      const removeTpChild = () => {
+        if (oldDom) {
+          let point = before;
+          do {
+            const next = this.nextSib(point);
+            this.remove(point, oldDom, null);
+            if (point === after) break;
+            point = next;
+          } while (true);
+        }
+      };
+      if (firstRender) {
+        if (dom) {
+          this.handleInsert(dom, after, null);
+          this.handleInsert(dom, before, null);
+        } else {
+          if (this.tokenizer.token.type === TokenType.Indent) {
+            const dentLen = this.tokenizer.dentStack[this.tokenizer.dentStack.length - 2] ?? 0;
+            this.tokenizer.skip(dentLen);
+          }
+        }
+      } else {
+        if (dom) {
+          if (oldDom) {
+            let point = before,
+              lastInsert = null;
+            do {
+              const next = this.nextSib(point);
+              const fakeNode = point[FakeNode];
+              if (fakeNode) {
+                fakeNode.realParent = dom;
+              }
+              this.handleInsert(dom, point, lastInsert);
+              if (point === after) break;
+              lastInsert = point;
+              point = next;
+            } while (true);
+          } else {
+            this.handleInsert(dom, after, null);
+            this.handleInsert(dom, before, null);
+            runWithPulling(() => {
+              this.tokenizer = node.owner.tokenizer;
+              this.tokenizer.resume(node.snapshot);
+              this.tokenizer.useDedentAsEof = false;
+              this.program(dom, node.owner, before, node);
+            }, scope);
+          }
+        } else {
+          removeTpChild();
+          scope.dispose();
+          scope = new Scope(() => {});
+          scope.scope = null;
+          runWithPulling(() => {
+            scope.get();
+          }, null);
+          node.effect = scope;
+        }
+      }
+      firstRender = false;
+      return isDestroy => {
+        if (isDestroy) {
+          removeTpChild();
+          scope.dispose();
+        }
+      };
+    }, [() => child.node], {
       type: 'render'
     });
     return node;
@@ -1761,7 +1879,7 @@ class Interpreter {
     const child = deepSignal({}, getPulling());
     const parentContext = this.ctx.stack.peekByType(NodeSort.Context)?.node?.context;
     if (parentContext) {
-      Object.setPrototypeOf(child, parentContext);
+      backupSignal(child, parentContext);
     }
     this.onePropParsed = createStoreOnePropParsed(child);
     const node = {
@@ -1771,7 +1889,7 @@ class Interpreter {
       realBefore: null,
       realAfter: null
     };
-    node.realAfter = this.insertAnchor('context-after');
+    node.realAfter = this.insertAnchor(node, 'context-after');
     return node;
   }
   formatForCollection(collection) {
@@ -1864,13 +1982,12 @@ class Interpreter {
       const rawGetKey = new Function('data', `with(data){return (${keyExp})}`);
       forNode.getKey = data => rawGetKey(safe(data));
     }
-    window['for1'] = forNode;
     const data = this.getData();
     const cells = data[Keys.Meta].cells;
     const hasArrExpKey = Reflect.has(data[Keys.Raw], arrExp);
     const arrSignal = hasArrExpKey ? (data[arrExp], cells.get(arrExp)) : new Computed(this.getFn(data, arrExp));
     forNode.arrSignal = arrSignal;
-    forNode.realAfter = this.insertAnchor('for-after');
+    forNode.realAfter = this.insertAnchor(forNode, 'for-after');
     const _forNode$snapshot = forNode.snapshot;
       _forNode$snapshot.dentStack;
       _forNode$snapshot.isFirstToken;
@@ -1893,8 +2010,8 @@ class Interpreter {
         const len = arr.length;
         for (let i = len; i--;) {
           const item = this.createForItem(forNode, i, data);
-          item.realAfter = this.insertAnchor('for-item-after');
-          item.realBefore = this.insertAnchor('for-item-before', true);
+          item.realAfter = this.insertAnchor(item, 'for-item-after');
+          item.realBefore = this.insertAnchor(item, 'for-item-before', true);
           item.realParent = forNode.realParent;
           children[i] = item;
         }
@@ -2056,10 +2173,14 @@ class Interpreter {
     }, ScheduleType.Render);
     return forNode.children[0] || forNode;
   }
+  anchorRefBack(anchor, node) {
+    anchor[FakeNode] = node;
+  }
   insertForItem(forNode, i, parentData, newChildren, before, snapshotForUpdate) {
     const item = this.createForItem(forNode, i, parentData);
     newChildren[i] = item;
     let realAfter = this.createAnchor('for-item-after');
+    this.anchorRefBack(realAfter, item);
     this.handleInsert(forNode.realParent, realAfter, before);
     let realBefore = this.createAnchor('for-item-before', true);
     this.handleInsert(forNode.realParent, realBefore, before);
@@ -2146,7 +2267,7 @@ class Interpreter {
         cells.set(name, new Computed(() => computedData.get()[name]));
       }
     }
-    Object.setPrototypeOf(data, parentData);
+    backupSignal(data, parentData);
     return data;
   }
   getData() {
@@ -2187,7 +2308,7 @@ class Interpreter {
     } else if (ComponentOrRender instanceof InlineFragment) {
       const conf = ComponentOrRender;
       child = deepSignal({}, getPulling(), true);
-      Object.setPrototypeOf(child, conf.data);
+      backupSignal(child, conf.data);
       tokenizer = conf.tokenizer;
       fragmentSnapshot = conf.snapshot;
       __logicType = FakeType.Fragment;
@@ -2197,7 +2318,7 @@ class Interpreter {
       const boundStore = render.boundStore;
       child = deepSignal({}, getPulling(), true);
       if (boundStore) {
-        Object.setPrototypeOf(child, boundStore);
+        backupSignal(child, boundStore);
       }
       tokenizer = render(true);
       __logicType = FakeType.Fragment;
@@ -2230,7 +2351,7 @@ class Interpreter {
       resumeSnapshot
     };
     this.onePropParsed = onePropParsed;
-    node.realAfter = this.insertAnchor('component-after');
+    node.realAfter = this.insertAnchor(node, 'component-after');
     return node;
   }
   getFn(data, expression) {
@@ -2325,7 +2446,7 @@ class Interpreter {
         break;
     }
     ifNode.condition = signal;
-    ifNode.realAfter = this.insertAnchor(`${keyWord.value}-after`);
+    ifNode.realAfter = this.insertAnchor(ifNode, `${keyWord.value}-after`);
     const ef = this.effect(({
       val
     }) => {
@@ -2368,10 +2489,11 @@ class Interpreter {
     const tokenizer = this.tokenizer;
     do {
       const isComponent = _node.__logicType & TokenizerSwitcherBit;
+      const isTp = _node.__logicType === FakeType.Tp;
       let snapshot, dentLen;
       const data = this.getData();
       const unHandledKey = this.attributeList(_node, data);
-      if (isComponent) {
+      if (isComponent || isTp) {
         snapshot = tokenizer.snapshot(undefined, -1);
         dentLen = tokenizer.dentStack[tokenizer.dentStack.length - 1];
       }
@@ -2383,6 +2505,9 @@ class Interpreter {
           if ((tokenizer.token.type & TokenType.Pipe) === 0) {
             break;
           }
+        } else if (isTp) {
+          _node.snapshot = snapshot;
+          break;
         } else {
           break;
         }
@@ -2441,7 +2566,7 @@ class Interpreter {
               prevKeys.delete(k);
               if (isComponent) {
                 const savedK = savedDefaults.has(k);
-                if (!savedK && Object.prototype.hasOwnProperty.call(rawTarget, k)) {
+                if (!savedK && hasOwn(rawTarget, k)) {
                   savedDefaults.set(k, rawTarget[k]);
                 }
                 const val = props[k];
@@ -2474,7 +2599,7 @@ class Interpreter {
             }).get();
           }
         } else if (hookType === 'dynamic') {
-          const valueIsMapKey = Reflect.has(data[Keys.Raw], value);
+          const valueIsMapKey = Boolean(getProxyHasKey(data, value));
           const fn = isFn ? rawVal : valueIsMapKey ? value : this.getFn(data, value);
           this.onePropParsed(data, _node, key, fn, valueIsMapKey, isFn, hookI);
         } else if (hookType === 'static') {