@lark.js/mvc 0.0.11 → 0.0.13

package/dist/devtool.cjs

@@ -785,61 +785,6 @@ var EventDelegator = {
   }
 };
 
-// src/safeguard.ts
-var proxiesPool = /* @__PURE__ */ new Map();
-var SAFEGUARD_SENTINEL = "_safe_";
-function safeguard(data, getter, setter, isRoot) {
-  if (typeof window.__lark_Debug === "undefined" || !window.__lark_Debug) {
-    return data;
-  }
-  if (typeof Proxy === "undefined") {
-    return data;
-  }
-  if (isPrimitive(data)) {
-    return data;
-  }
-  const build = (prefix, obj) => {
-    const cacheKey = (getter || "") + "
" + (setter || "");
-    const cached = proxiesPool.get(obj);
-    if (cached && cached.cacheKey === cacheKey) {
-      return cached.entity;
-    }
-    if (Reflect.get(obj, SAFEGUARD_SENTINEL)) {
-      return obj;
-    }
-    const entity = new Proxy(obj, {
-      set(target, property, value) {
-        if (!setter && !prefix) {
-          throw new Error(
-            "Avoid write back, key: " + prefix + property + " value:" + value + " more: https://github.com/hangtiancheng/lark"
-          );
-        }
-        Reflect.set(target, property, value);
-        if (setter) {
-          setter(prefix + property, value);
-        }
-        return true;
-      },
-      get(target, property) {
-        if (property === SAFEGUARD_SENTINEL) {
-          return true;
-        }
-        const out = Reflect.get(target, property);
-        if (!prefix && getter) {
-          getter(property);
-        }
-        if (!isRoot && hasOwnProperty(target, property) && (Array.isArray(out) || isPlainObject(out))) {
-          return build(prefix + property + ".", out);
-        }
-        return out;
-      }
-    });
-    proxiesPool.set(obj, { cacheKey, entity });
-    return entity;
-  };
-  return build("", data);
-}
-
 // src/module-loader.ts
 var config = {
   rootId: "root",
@@ -1157,18 +1102,6 @@ var DOM_SPECIALS = {
 function isSameVDomNode(a, b) {
   return a.compareKey && b.compareKey === a.compareKey || !a.compareKey && !b.compareKey && a.tag === b.tag || a.tag === SPLITTER || b.tag === SPLITTER;
 }
-function getKeyNodes(list, nodes, start, end, realEnd) {
-  const keyedNodes = {};
-  for (let i = end, re = realEnd; i >= start; i--, re--) {
-    const oc = list[i];
-    const cKey = oc.compareKey;
-    if (cKey) {
-      const bucket = keyedNodes[cKey] || (keyedNodes[cKey] = []);
-      bucket.push(nodes[re]);
-    }
-  }
-  return keyedNodes;
-}
 function vdomCreateNode(vnode, owner, ref) {
   const tag = vnode.tag;
   if (tag === V_TEXT_NODE) {
@@ -1257,9 +1190,10 @@ function vdomSetNode(realNode, oldParent, lastVDom, newVDom, ref, frame, keys, r
     return;
   }
   if (lastTag === newTag) {
-    const lastAMap = lastVDom.attrsMap || {};
-    const newAMap = newVDom.attrsMap || {};
-    if (lastVDom.compareKey && lastVDom.compareKey === newVDom.compareKey && !lastAMap["id"] && !newAMap["id"]) {
+    if (lastVDom.attrs === newVDom.attrs && lastVDom.html === newVDom.html) {
+      if (newVDom.hasSpecials) {
+        vdomSyncFormState(realNode, newVDom);
+      }
       return;
     }
     let attrChanged = 0;
@@ -1300,261 +1234,209 @@ function vdomSetNode(realNode, oldParent, lastVDom, newVDom, ref, frame, keys, r
     oldParent.replaceChild(vdomCreateNode(newVDom, oldParent, ref), realNode);
   }
 }
+function computeLIS(sequence) {
+  const len = sequence.length;
+  if (len === 0) return [];
+  const result = [];
+  const tails = [];
+  const predecessors = new Array(len);
+  let lisLength = 0;
+  for (let i = 0; i < len; i++) {
+    const value = sequence[i];
+    if (value < 0) continue;
+    let lo = 0;
+    let hi = lisLength;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (sequence[tails[mid]] < value) lo = mid + 1;
+      else hi = mid;
+    }
+    tails[lo] = i;
+    predecessors[i] = lo > 0 ? tails[lo - 1] : -1;
+    if (lo === lisLength) lisLength++;
+  }
+  let cursor = tails[lisLength - 1];
+  for (let i = lisLength - 1; i >= 0; i--) {
+    result[i] = cursor;
+    cursor = predecessors[cursor];
+  }
+  return result;
+}
 function vdomSetChildNodes(realNode, lastVDom, newVDom, ref, frame, keys, view, ready) {
   if (!lastVDom) {
     ref.changed = 1;
     realNode.innerHTML = newVDom.html;
+    callFunction(ready, []);
     return;
   }
   if (lastVDom.html === newVDom.html) {
+    callFunction(ready, []);
     return;
   }
   const oldChildren = lastVDom.children;
   const newChildren = newVDom.children;
   const oldLen = oldChildren?.length || 0;
   const newLen = newChildren?.length || 0;
-  if (oldLen === 0 && newLen === 0) return;
+  if (oldLen === 0 && newLen === 0) {
+    callFunction(ready, []);
+    return;
+  }
   const nodes = realNode.childNodes;
-  let oldStart = 0;
-  let oldEnd = oldLen - 1;
-  let newStart = 0;
-  let newEnd = newLen - 1;
-  let realStart = oldStart;
-  let realEnd = oldEnd;
-  let keyedNodes;
-  const oldReusedTotal = lastVDom.reusedTotal || 0;
-  const newReusedTotal = newVDom.reusedTotal || 0;
-  let oldStartNode = oldChildren?.[oldStart];
-  let oldEndNode = oldChildren?.[oldEnd];
-  let newStartNode = newChildren?.[newStart];
-  let newEndNode = newChildren?.[newEnd];
-  while (oldStart <= oldEnd && newStart <= newEnd) {
-    if (!oldStartNode) {
-      oldStartNode = oldChildren?.[++oldStart];
-      realStart++;
-      continue;
-    }
-    if (!oldEndNode) {
-      oldEndNode = oldChildren?.[--oldEnd];
-      realEnd--;
-      continue;
-    }
-    if (isSameVDomNode(newStartNode, oldStartNode)) {
-      if (newStartNode.tag === SPLITTER || oldStartNode.tag === SPLITTER) {
-        ref.changed = 1;
-        domUnmountFrames(frame, realNode);
-        if (newStartNode.tag === SPLITTER) {
-          realNode.innerHTML = newStartNode.html;
-        } else {
-          realNode.innerHTML = "";
-          realNode.appendChild(vdomCreateNode(newStartNode, realNode, ref));
-        }
-      } else {
-        vdomSetNode(
-          nodes[realStart],
-          realNode,
-          oldStartNode,
-          newStartNode,
-          ref,
-          frame,
-          keys,
-          view,
-          ready
-        );
-      }
-      reduceCached(keyedNodes, oldStartNode, nodes[realStart]);
-      realStart++;
-      oldStartNode = oldChildren?.[++oldStart];
-      newStartNode = newChildren?.[++newStart];
-    } else if (isSameVDomNode(newEndNode, oldEndNode)) {
-      if (newEndNode.tag === SPLITTER || oldEndNode.tag === SPLITTER) {
-        ref.changed = 1;
-        domUnmountFrames(frame, realNode);
-        realNode.innerHTML = newEndNode.tag === SPLITTER ? newEndNode.html : "";
-        if (newEndNode.tag !== SPLITTER) {
-          realNode.appendChild(vdomCreateNode(newEndNode, realNode, ref));
-        }
-      } else {
-        vdomSetNode(
-          nodes[realEnd],
-          realNode,
-          oldEndNode,
-          newEndNode,
-          ref,
-          frame,
-          keys,
-          view,
-          ready
-        );
-      }
-      reduceCached(keyedNodes, oldEndNode, nodes[realEnd]);
-      realEnd--;
-      oldEndNode = oldChildren?.[--oldEnd];
-      newEndNode = newChildren?.[--newEnd];
-    } else if (isSameVDomNode(newEndNode, oldStartNode)) {
-      if (newEndNode.tag === SPLITTER || oldStartNode.tag === SPLITTER) {
-        ref.changed = 1;
-        domUnmountFrames(frame, realNode);
-        realNode.innerHTML = newEndNode.tag === SPLITTER ? newEndNode.html : "";
-        if (newEndNode.tag !== SPLITTER) {
-          realNode.appendChild(vdomCreateNode(newEndNode, realNode, ref));
-        }
-      } else {
-        const oi = nodes[realStart];
-        realNode.insertBefore(oi, nodes[realEnd + 1] || null);
-        vdomSetNode(
-          oi,
-          realNode,
-          oldStartNode,
-          newEndNode,
-          ref,
-          frame,
-          keys,
-          view,
-          ready
-        );
-      }
-      reduceCached(keyedNodes, oldStartNode, nodes[realStart]);
-      realStart++;
-      oldStartNode = oldChildren?.[++oldStart];
-      newEndNode = newChildren?.[--newEnd];
-    } else if (isSameVDomNode(newStartNode, oldEndNode)) {
-      if (newStartNode.tag === SPLITTER || oldEndNode.tag === SPLITTER) {
-        ref.changed = 1;
-        domUnmountFrames(frame, realNode);
-        realNode.innerHTML = newStartNode.tag === SPLITTER ? newStartNode.html : "";
-        if (newStartNode.tag !== SPLITTER) {
-          realNode.appendChild(vdomCreateNode(newStartNode, realNode, ref));
-        }
-      } else {
-        const oi = nodes[realEnd];
-        realNode.insertBefore(oi, nodes[realStart]);
-        vdomSetNode(
-          oi,
-          realNode,
-          oldEndNode,
-          newStartNode,
-          ref,
-          frame,
-          keys,
-          view,
-          ready
-        );
-      }
-      reduceCached(keyedNodes, oldEndNode, nodes[realEnd]);
-      realEnd--;
-      oldEndNode = oldChildren?.[--oldEnd];
-      newStartNode = newChildren?.[++newStart];
+  const oldDomNodes = new Array(oldLen);
+  for (let i = 0; i < oldLen; i++) {
+    oldDomNodes[i] = nodes[i];
+  }
+  const usedOldDomNodes = /* @__PURE__ */ new Set();
+  let headIdx = 0;
+  let tailIdx = oldLen - 1;
+  let newHead = 0;
+  let newTail = newLen - 1;
+  while (headIdx <= tailIdx && newHead <= newTail) {
+    const oc = oldChildren[headIdx];
+    const nc = newChildren[newHead];
+    if (!isSameVDomNode(nc, oc)) break;
+    if (nc.tag === SPLITTER || oc.tag === SPLITTER) break;
+    vdomSetNode(
+      oldDomNodes[headIdx],
+      realNode,
+      oc,
+      nc,
+      ref,
+      frame,
+      keys,
+      view,
+      ready
+    );
+    usedOldDomNodes.add(oldDomNodes[headIdx]);
+    headIdx++;
+    newHead++;
+  }
+  while (headIdx <= tailIdx && newHead <= newTail) {
+    const oc = oldChildren[tailIdx];
+    const nc = newChildren[newTail];
+    if (!isSameVDomNode(nc, oc)) break;
+    if (nc.tag === SPLITTER || oc.tag === SPLITTER) break;
+    vdomSetNode(
+      oldDomNodes[tailIdx],
+      realNode,
+      oc,
+      nc,
+      ref,
+      frame,
+      keys,
+      view,
+      ready
+    );
+    usedOldDomNodes.add(oldDomNodes[tailIdx]);
+    tailIdx--;
+    newTail--;
+  }
+  if (headIdx > tailIdx && newHead > newTail) {
+    if (ref.asyncCount === 0) callFunction(ready, []);
+    return;
+  }
+  const keyMap = {};
+  for (let i = headIdx; i <= tailIdx; i++) {
+    const c = oldChildren[i];
+    if (c?.compareKey) {
+      if (!keyMap[c.compareKey]) keyMap[c.compareKey] = [];
+      keyMap[c.compareKey].push({ domNode: oldDomNodes[i], vdomNode: c });
+    }
+  }
+  const newRemaining = newTail - newHead + 1;
+  const sequence = new Array(newRemaining);
+  for (let i = 0; i < newRemaining; i++) {
+    const nc = newChildren[newHead + i];
+    const cKey = nc.compareKey;
+    const entries = cKey ? keyMap[cKey] : void 0;
+    if (entries && entries.length > 0) {
+      const entry = entries.shift();
+      if (entries.length === 0) delete keyMap[cKey];
+      const oldIdx = oldChildren.indexOf(entry.vdomNode, headIdx);
+      sequence[i] = oldIdx >= 0 ? oldIdx : -1;
+      usedOldDomNodes.add(entry.domNode);
     } else {
-      if (!keyedNodes && newReusedTotal > 0 && oldReusedTotal > 0) {
-        keyedNodes = getKeyNodes(
-          oldChildren,
-          nodes,
-          oldStart,
-          oldEnd,
-          realEnd
-        );
-      }
-      const cKey = newStartNode.compareKey;
-      let found;
-      let compareKey;
-      if (cKey && keyedNodes) {
-        found = keyedNodes[cKey];
-        compareKey = void 0;
-        while (found && found.length > 0) {
-          compareKey = found.pop();
-          if (compareKey) break;
-        }
-        if (found && found.length === 0) delete keyedNodes[cKey];
-      }
-      if (compareKey) {
-        if (compareKey !== nodes[realStart]) {
-          for (let j = oldStart + 1; j <= oldEnd; j++) {
-            const oc = oldChildren?.[j];
-            if (oc && nodes[realStart + (j - oldStart)] === compareKey) {
-              oldChildren[j] = void 0;
-              break;
-            }
-          }
-          realNode.insertBefore(compareKey, nodes[realStart]);
-        }
-        vdomSetNode(
-          compareKey,
-          realNode,
-          oldStartNode,
-          newStartNode,
-          ref,
-          frame,
-          keys,
-          view,
-          ready
-        );
-      } else if (oldStartNode.compareKey && lastVDom.reused?.[oldStartNode.compareKey] && newVDom.reused?.[oldStartNode.compareKey] || nodes[realStart]?.id && realNode.querySelectorAll?.(
-        `#${nodes[realStart].id}`
-      )?.length && !newStartNode.isLarkView) {
+      sequence[i] = -1;
+    }
+  }
+  if (newHead > newTail) {
+    for (let i = 0; i < oldLen; i++) {
+      const domNode = oldDomNodes[i];
+      if (domNode && !usedOldDomNodes.has(domNode) && domNode.parentNode === realNode) {
+        domUnmountFrames(frame, domNode);
         ref.changed = 1;
-        const newNode = vdomCreateNode(newStartNode, realNode, ref);
-        realNode.insertBefore(newNode, nodes[realStart]);
-        realStart--;
-        realEnd++;
-      } else {
-        vdomSetNode(
-          nodes[realStart],
-          realNode,
-          oldStartNode,
-          newStartNode,
-          ref,
-          frame,
-          keys,
-          view,
-          ready
-        );
+        realNode.removeChild(domNode);
       }
-      realStart++;
-      oldStartNode = oldChildren?.[++oldStart];
-      newStartNode = newChildren?.[++newStart];
     }
+    if (ref.asyncCount === 0) callFunction(ready, []);
+    return;
   }
-  if (newStart <= newEnd) {
-    const refNode = nodes[realEnd + 1] || null;
-    for (let i = newStart; i <= newEnd; i++) {
+  if (headIdx > tailIdx) {
+    const insertRef = tailIdx < oldLen ? oldDomNodes[tailIdx + 1] ?? null : null;
+    for (let i = newHead; i <= newTail; i++) {
+      ref.changed = 1;
+      const newNode = vdomCreateNode(newChildren[i], realNode, ref);
+      realNode.insertBefore(newNode, insertRef);
+    }
+    if (ref.asyncCount === 0) callFunction(ready, []);
+    return;
+  }
+  const lis = computeLIS(sequence);
+  let lisCursor = lis.length - 1;
+  let nextNode = tailIdx + 1 < oldLen ? oldDomNodes[tailIdx + 1] : null;
+  for (let j = newRemaining - 1; j >= 0; j--) {
+    const newIdx = newHead + j;
+    const nc = newChildren[newIdx];
+    if (lisCursor >= 0 && lis[lisCursor] === j) {
+      const oldIdx = sequence[j];
+      vdomSetNode(
+        oldDomNodes[oldIdx],
+        realNode,
+        oldChildren[oldIdx],
+        nc,
+        ref,
+        frame,
+        keys,
+        view,
+        ready
+      );
+      nextNode = oldDomNodes[oldIdx];
+      lisCursor--;
+    } else if (sequence[j] >= 0) {
+      const oldIdx = sequence[j];
+      ref.changed = 1;
+      realNode.insertBefore(oldDomNodes[oldIdx], nextNode);
+      vdomSetNode(
+        oldDomNodes[oldIdx],
+        realNode,
+        oldChildren[oldIdx],
+        nc,
+        ref,
+        frame,
+        keys,
+        view,
+        ready
+      );
+      nextNode = oldDomNodes[oldIdx];
+    } else {
       ref.changed = 1;
-      const nc = newChildren[i];
-      if (nc.tag === SPLITTER) {
-        domUnmountFrames(frame, realNode);
-        realNode.innerHTML = nc.html;
-        return;
-      }
       const newNode = vdomCreateNode(nc, realNode, ref);
-      realNode.insertBefore(newNode, refNode);
+      realNode.insertBefore(newNode, nextNode);
+      nextNode = newNode;
     }
   }
-  if (oldStart <= oldEnd) {
-    for (let i = realEnd; i >= realStart; i--) {
-      const node = nodes[i];
-      if (node) {
-        domUnmountFrames(frame, node);
-        ref.changed = 1;
-        realNode.removeChild(node);
-      }
+  for (let i = 0; i < oldLen; i++) {
+    const domNode = oldDomNodes[i];
+    if (domNode && !usedOldDomNodes.has(domNode) && domNode.parentNode === realNode) {
+      domUnmountFrames(frame, domNode);
+      ref.changed = 1;
+      realNode.removeChild(domNode);
     }
   }
   if (ref.asyncCount === 0) {
     callFunction(ready, []);
   }
 }
-function reduceCached(keyedNodes, node, compared) {
-  if (!keyedNodes || !node.compareKey) return;
-  const bucket = keyedNodes[node.compareKey];
-  if (bucket) {
-    for (let i = bucket.length; i--; ) {
-      if (bucket[i] === compared) {
-        bucket[i] = void 0;
-        break;
-      }
-    }
-  }
-}
 function createVDomRef(viewId) {
   return {
     viewId,
@@ -1607,9 +1489,6 @@ var Updater = class {
     if (key) {
       result = this.data[key];
     }
-    if (typeof window !== "undefined" && window.__lark_Debug) {
-      return safeguard(result);
-    }
     return result;
   }
   /**
@@ -1697,9 +1576,6 @@ var Updater = class {
             view,
             ready
           );
-          if (ref.asyncCount === 0) {
-            ready();
-          }
         } else {
           const html = template(
             this.data,
@@ -1988,9 +1864,6 @@ var Router = {
       attachViewAndPath(location);
       hrefCache.set(href, location);
     }
-    if (typeof window.__lark_Debug !== "undefined" && window.__lark_Debug) {
-      location["params"] = safeguard(location["params"]);
-    }
     return location;
   },
   /**
@@ -2009,9 +1882,6 @@ var Router = {
       emitter.fire(RouterEvents.CHANGED, asRecord(lastChanged));
     }
     silent = 0;
-    if (typeof window.__lark_Debug !== "undefined" && window.__lark_Debug && lastChanged) {
-      lastChanged = safeguard(lastChanged);
-    }
     return lastChanged;
   },
   /**
@@ -2196,6 +2066,60 @@ var Router = {
   }
 };
 
+// src/view-registry.ts
+var viewClassRegistry = {};
+function getViewClass(path) {
+  return viewClassRegistry[path];
+}
+function registerViewClass(viewPath, ViewClass) {
+  const parsed = parseUri(viewPath);
+  const path = parsed.path;
+  if (path) {
+    viewClassRegistry[path] = ViewClass;
+  }
+}
+function invalidateViewClass(viewPath) {
+  const parsed = parseUri(viewPath);
+  const path = parsed.path;
+  if (path) {
+    Reflect.deleteProperty(viewClassRegistry, path);
+  }
+}
+
+// src/hmr.ts
+function reloadViews(viewPath) {
+  const allFrames = Frame.getAll();
+  const toReload = [];
+  for (const [, frame] of allFrames) {
+    if (frame.viewPath) {
+      const parsed = parseUri(frame.viewPath);
+      if (parsed.path === viewPath) {
+        toReload.push({ frame, fullPath: frame.viewPath });
+      }
+    }
+  }
+  for (const { frame, fullPath } of toReload) {
+    frame.mountView(fullPath);
+  }
+}
+function acceptView(hot, viewPath) {
+  hot.accept((newModule) => {
+    const candidate = newModule?.default ?? newModule;
+    if (typeof candidate === "function") {
+      const NewViewClass = candidate;
+      registerViewClass(viewPath, NewViewClass);
+      reloadViews(viewPath);
+    } else {
+      hot.invalidate();
+    }
+  });
+}
+function disposeView(hot, viewPath) {
+  hot.dispose(() => {
+    invalidateViewClass(viewPath);
+  });
+}
+
 // src/view.ts
 var VIEW_GLOBALS = {};
 if (typeof window !== "undefined") {
@@ -2786,20 +2710,47 @@ var View = class _View {
     _View.mergeMixins(mixins, this, existingCtors);
     return this;
   }
-};
-
-// src/view-registry.ts
-var viewClassRegistry = {};
-function getViewClass(path) {
-  return viewClassRegistry[path];
-}
-function registerViewClass(viewPath, ViewClass) {
-  const parsed = parseUri(viewPath);
-  const path = parsed.path;
-  if (path) {
-    viewClassRegistry[path] = ViewClass;
+  // ============================================================
+  // HMR support (static accept / dispose)
+  // ============================================================
+  /**
+   * Set up HMR accept handler for this view module.
+   *
+   * When the module is hot-replaced, the new View class is extracted from
+   * the new module, registered in the view registry, and all currently
+   * mounted frames using this viewPath are re-mounted.
+   *
+   * No-op when `hot` is undefined (production / non-HMR environment).
+   *
+   * ```ts
+   * if (import.meta.hot) {
+   *   HomeView.accept(import.meta.hot, 'home');
+   * }
+   * ```
+   */
+  static accept(hot, viewPath) {
+    if (!hot) return;
+    acceptView(hot, viewPath);
   }
-}
+  /**
+   * Set up HMR dispose handler for this view module.
+   *
+   * When the module is about to be replaced, the old View class is removed
+   * from the registry so subsequent lookups don't return the stale class.
+   *
+   * No-op when `hot` is undefined (production / non-HMR environment).
+   *
+   * ```ts
+   * if (import.meta.hot) {
+   *   HomeView.dispose(import.meta.hot, 'home');
+   * }
+   * ```
+   */
+  static dispose(hot, viewPath) {
+    if (!hot) return;
+    disposeView(hot, viewPath);
+  }
+};
 
 // src/frame.ts
 var frameRegistry = /* @__PURE__ */ new Map();