@lark.js/mvc 0.0.11 → 0.0.12

package/dist/index.cjs

@@ -53,6 +53,7 @@ __export(index_exports, {
   markRouterBooted: () => markRouterBooted,
   nextCounter: () => nextCounter,
   registerViewClass: () => registerViewClass,
+  reloadViews: () => reloadViews,
   resetProjectsMap: () => resetProjectsMap,
   safeguard: () => safeguard,
   unmark: () => unmark,
@@ -85,7 +86,6 @@ var MATH_NS = "http://www.w3.org/1998/Math/MathML";
 var TAG_NAME_REGEXP = /<([a-z][^/\0>\x20\t\r\n\f]+)/i;
 var CALL_BREAK_TIME = 48;
 var V_TEXT_NODE = 0;
-var TAG_STATIC_KEY = "_";
 var VDOM_NS_MAP = {
   svg: SVG_NS,
   math: MATH_NS
@@ -1891,7 +1891,7 @@ function vdomCreate(tag, props, children, specials) {
     } else if (value === true) {
       propsObj[prop] = value = specialsObj[prop] ? value : "";
     }
-    if ((prop === "#" || prop === "id" || prop === TAG_STATIC_KEY) && !compareKey) {
+    if ((prop === "#" || prop === "id") && !compareKey) {
       compareKey = value;
       if (prop !== "id") {
         delete propsObj[prop];
@@ -1938,18 +1938,6 @@ function vdomCreate(tag, props, children, 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) {
@@ -2038,9 +2026,10 @@ function vdomSetNode(realNode, oldParent, lastVDom, newVDom, ref, frame, keys2,
     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;
@@ -2081,261 +2070,209 @@ function vdomSetNode(realNode, oldParent, lastVDom, newVDom, ref, frame, keys2,
     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, keys2, 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,
-          keys2,
-          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,
-          keys2,
-          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,
-          keys2,
-          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,
-          keys2,
-          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,
+      keys2,
+      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,
+      keys2,
+      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,
-          keys2,
-          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,
-          keys2,
-          view,
-          ready
-        );
+        realNode.removeChild(domNode);
       }
-      realStart++;
-      oldStartNode = oldChildren?.[++oldStart];
-      newStartNode = newChildren?.[++newStart];
     }
+    if (ref.asyncCount === 0) callFunction(ready, []);
+    return;
+  }
+  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;
   }
-  if (newStart <= newEnd) {
-    const refNode = nodes[realEnd + 1] || null;
-    for (let i = newStart; i <= newEnd; i++) {
+  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,
+        keys2,
+        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,
+        keys2,
+        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,
@@ -2478,9 +2415,6 @@ var Updater = class {
             view,
             ready
           );
-          if (ref.asyncCount === 0) {
-            ready();
-          }
         } else {
           const html = template(
             this.data,
@@ -2579,6 +2513,63 @@ var Updater = class {
   }
 };
 
+// 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);
+  }
+}
+function getViewClassRegistry() {
+  return viewClassRegistry;
+}
+
+// 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") {
@@ -3169,34 +3160,51 @@ var View = class _View {
     _View.mergeMixins(mixins, this, existingCtors);
     return this;
   }
+  // ============================================================
+  // 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);
+  }
 };
 function defineView(props, statics) {
   return View.extend(props, statics);
 }
 
-// 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);
-  }
-}
-function getViewClassRegistry() {
-  return viewClassRegistry;
-}
-
 // src/frame.ts
 var frameRegistry = /* @__PURE__ */ new Map();
 var rootFrame;
@@ -4878,6 +4886,7 @@ function bindStore(view, store, selector) {
   markRouterBooted,
   nextCounter,
   registerViewClass,
+  reloadViews,
   resetProjectsMap,
   safeguard,
   unmark,