@fictjs/runtime 0.0.11 → 0.0.12

package/dist/slim.js

@@ -260,7 +260,7 @@ function handleError(err, info, startRoot) {
       }
     }
   }
-  throw error;
+  return false;
 }
 function handleSuspend(token, startRoot) {
   let root = startRoot ?? currentRoot;
@@ -306,6 +306,10 @@ var enqueueMicrotask = typeof queueMicrotask === "function" ? queueMicrotask : (
   Promise.resolve().then(fn);
 };
 var inCleanup = false;
+var SIGNAL_MARKER = Symbol.for("fict:signal");
+var COMPUTED_MARKER = Symbol.for("fict:computed");
+var EFFECT_MARKER = Symbol.for("fict:effect");
+var EFFECT_SCOPE_MARKER = Symbol.for("fict:effectScope");
 function link(dep, sub, version) {
   const prevDep = sub.depsTail;
   if (prevDep !== void 0 && prevDep.dep === dep) return;
@@ -429,13 +433,21 @@ function checkDirty(firstLink, sub) {
         dirty = true;
       }
     } else if ((depFlags & MutablePending) === MutablePending) {
-      if (link2.nextSub !== void 0 || link2.prevSub !== void 0) {
-        stack = { value: link2, prev: stack };
+      if (!dep.deps) {
+        const nextDep = link2.nextDep;
+        if (nextDep !== void 0) {
+          link2 = nextDep;
+          continue;
+        }
+      } else {
+        if (link2.nextSub !== void 0 || link2.prevSub !== void 0) {
+          stack = { value: link2, prev: stack };
+        }
+        link2 = dep.deps;
+        sub = dep;
+        ++checkDepth;
+        continue;
       }
-      link2 = dep.deps;
-      sub = dep;
-      ++checkDepth;
-      continue;
     }
     if (!dirty) {
       const nextDep = link2.nextDep;
@@ -513,8 +525,12 @@ function disposeNode(node) {
   node.depsTail = void 0;
   node.flags = 0;
   purgeDeps(node);
-  const sub = node.subs;
-  if (sub !== void 0) unlink(sub, node);
+  let sub = node.subs;
+  while (sub !== void 0) {
+    const next = sub.nextSub;
+    unlink(sub);
+    sub = next;
+  }
 }
 function updateSignal(s) {
   s.flags = Mutable;
@@ -683,7 +699,9 @@ function signal(initialValue) {
     __id: void 0
   };
   registerSignalDevtools(initialValue, s);
-  return signalOper.bind(s);
+  const accessor = signalOper.bind(s);
+  accessor[SIGNAL_MARKER] = true;
+  return accessor;
 }
 function signalOper(value) {
   if (arguments.length > 0) {
@@ -728,6 +746,7 @@ function computed(getter) {
     getter
   };
   const bound = computedOper.bind(c);
+  bound[COMPUTED_MARKER] = true;
   return bound;
 }
 function computedOper() {
@@ -780,7 +799,9 @@ function effect(fn) {
     activeSub = prevSub;
     e.flags &= ~Running;
   }
-  return effectOper.bind(e);
+  const disposer = effectOper.bind(e);
+  disposer[EFFECT_MARKER] = true;
+  return disposer;
 }
 function effectWithCleanup(fn, cleanupRunner) {
   const e = {
@@ -804,7 +825,9 @@ function effectWithCleanup(fn, cleanupRunner) {
     activeSub = prevSub;
     e.flags &= ~Running;
   }
-  return effectOper.bind(e);
+  const disposer = effectOper.bind(e);
+  disposer[EFFECT_MARKER] = true;
+  return disposer;
 }
 function effectOper() {
   disposeNode(this);
@@ -819,7 +842,9 @@ function effectScope(fn) {
   } finally {
     activeSub = prevSub;
   }
-  return effectScopeOper.bind(e);
+  const disposer = effectScopeOper.bind(e);
+  disposer[EFFECT_SCOPE_MARKER] = true;
+  return disposer;
 }
 function effectScopeOper() {
   disposeNode(this);
@@ -1504,9 +1529,6 @@ function mergeProps(...sources) {
   };
   return new Proxy({}, {
     get(_, prop) {
-      if (typeof prop === "symbol") {
-        return void 0;
-      }
       for (let i = validSources.length - 1; i >= 0; i--) {
         const src = validSources[i];
         const raw = resolveSource(src);
@@ -1787,7 +1809,8 @@ function applyRef(el, value) {
   if (typeof value === "function") {
     const refFn = value;
     refFn(el);
-    if (getCurrentRoot()) {
+    const root = getCurrentRoot();
+    if (root) {
       registerRootCleanup(() => {
         refFn(null);
       });
@@ -1795,7 +1818,8 @@ function applyRef(el, value) {
   } else if (value && typeof value === "object" && "current" in value) {
     const refObj = value;
     refObj.current = el;
-    if (getCurrentRoot()) {
+    const root = getCurrentRoot();
+    if (root) {
       registerRootCleanup(() => {
         refObj.current = null;
       });
@@ -2206,8 +2230,6 @@ function reconcileArrays(parentNode, a, b) {
     }
   }
 }
-
-// src/list-helpers.ts
 function moveNodesBefore(parent, nodes, anchor) {
   for (let i = nodes.length - 1; i >= 0; i--) {
     const node = nodes[i];
@@ -2269,6 +2291,7 @@ function removeBlockRange(block) {
     cursor = next;
   }
 }
+var MAX_SAFE_VERSION = 9007199254740991;
 function createVersionedSignalAccessor(initialValue) {
   let current = initialValue;
   let version = 0;
@@ -2279,7 +2302,7 @@ function createVersionedSignalAccessor(initialValue) {
       return current;
     }
     current = value;
-    version++;
+    version = version >= MAX_SAFE_VERSION ? 1 : version + 1;
     track(version);
   }
   return accessor;
@@ -2335,15 +2358,21 @@ function createKeyedBlock(key, item, index, render2, needsIndex = true, hostRoot
   });
   const root = createRootContext(hostRoot);
   const prevRoot = pushRoot(root);
-  const prevSub = setActiveSub(void 0);
   let nodes = [];
+  let scopeDispose;
+  const prevSub = setActiveSub(void 0);
   try {
-    const rendered = render2(itemSig, indexSig, key);
-    if (rendered instanceof Node || Array.isArray(rendered) && rendered.every((n) => n instanceof Node)) {
-      nodes = toNodeArray(rendered);
-    } else {
-      const element = createElement(rendered);
-      nodes = toNodeArray(element);
+    scopeDispose = effectScope(() => {
+      const rendered = render2(itemSig, indexSig, key);
+      if (rendered instanceof Node || Array.isArray(rendered) && rendered.every((n) => n instanceof Node)) {
+        nodes = toNodeArray(rendered);
+      } else {
+        const element = createElement(rendered);
+        nodes = toNodeArray(element);
+      }
+    });
+    if (scopeDispose) {
+      root.cleanups.push(scopeDispose);
     }
   } finally {
     setActiveSub(prevSub);
@@ -2362,6 +2391,86 @@ function createKeyedBlock(key, item, index, render2, needsIndex = true, hostRoot
 function getFirstNodeAfter(marker) {
   return marker.nextSibling;
 }
+function reorderBySwap(parent, first, second) {
+  if (first === second) return false;
+  const firstNodes = first.nodes;
+  const secondNodes = second.nodes;
+  if (firstNodes.length === 0 || secondNodes.length === 0) return false;
+  const lastFirst = firstNodes[firstNodes.length - 1];
+  const lastSecond = secondNodes[secondNodes.length - 1];
+  const afterFirst = lastFirst.nextSibling;
+  const afterSecond = lastSecond.nextSibling;
+  moveNodesBefore(parent, firstNodes, afterSecond);
+  moveNodesBefore(parent, secondNodes, afterFirst);
+  return true;
+}
+function getLISIndices(sequence) {
+  const predecessors = new Array(sequence.length);
+  const result = [];
+  for (let i = 0; i < sequence.length; i++) {
+    const value = sequence[i];
+    if (value < 0) {
+      predecessors[i] = -1;
+      continue;
+    }
+    let low = 0;
+    let high = result.length;
+    while (low < high) {
+      const mid = low + high >> 1;
+      if (sequence[result[mid]] < value) {
+        low = mid + 1;
+      } else {
+        high = mid;
+      }
+    }
+    predecessors[i] = low > 0 ? result[low - 1] : -1;
+    if (low === result.length) {
+      result.push(i);
+    } else {
+      result[low] = i;
+    }
+  }
+  const lis = new Array(result.length);
+  let k = result.length > 0 ? result[result.length - 1] : -1;
+  for (let i = result.length - 1; i >= 0; i--) {
+    lis[i] = k;
+    k = predecessors[k];
+  }
+  return lis;
+}
+function reorderByLIS(parent, endMarker, prev, next) {
+  const positions = /* @__PURE__ */ new Map();
+  for (let i = 0; i < prev.length; i++) {
+    positions.set(prev[i], i);
+  }
+  const sequence = new Array(next.length);
+  for (let i = 0; i < next.length; i++) {
+    const position = positions.get(next[i]);
+    if (position === void 0) return false;
+    sequence[i] = position;
+  }
+  const lisIndices = getLISIndices(sequence);
+  if (lisIndices.length === sequence.length) return true;
+  const inLIS = new Array(sequence.length).fill(false);
+  for (let i = 0; i < lisIndices.length; i++) {
+    inLIS[lisIndices[i]] = true;
+  }
+  let anchor = endMarker;
+  let moved = false;
+  for (let i = next.length - 1; i >= 0; i--) {
+    const block = next[i];
+    const nodes = block.nodes;
+    if (nodes.length === 0) continue;
+    if (inLIS[i]) {
+      anchor = nodes[0];
+      continue;
+    }
+    moveNodesBefore(parent, nodes, anchor);
+    anchor = nodes[0];
+    moved = true;
+  }
+  return moved;
+}
 function createKeyedList(getItems, keyFn, renderItem, needsIndex) {
   const resolvedNeedsIndex = arguments.length >= 4 ? !!needsIndex : renderItem.length > 1;
   return createFineGrainedKeyedList(getItems, keyFn, renderItem, resolvedNeedsIndex);
@@ -2394,10 +2503,6 @@ function createFineGrainedKeyedList(getItems, keyFn, renderItem, needsIndex) {
       const prevOrderedBlocks = container.orderedBlocks;
       const nextOrderedBlocks = container.nextOrderedBlocks;
       const orderedIndexByKey = container.orderedIndexByKey;
-      newBlocks.clear();
-      nextOrderedBlocks.length = 0;
-      orderedIndexByKey.clear();
-      const createdBlocks = [];
       const newItems = getItems();
       if (newItems.length === 0) {
         if (oldBlocks.size > 0) {
@@ -2420,8 +2525,44 @@ function createFineGrainedKeyedList(getItems, keyFn, renderItem, needsIndex) {
         return;
       }
       const prevCount = prevOrderedBlocks.length;
+      if (prevCount > 0 && newItems.length === prevCount && orderedIndexByKey.size === prevCount) {
+        let stableOrder = true;
+        const seen = /* @__PURE__ */ new Set();
+        for (let i = 0; i < prevCount; i++) {
+          const item = newItems[i];
+          const key = keyFn(item, i);
+          if (seen.has(key) || prevOrderedBlocks[i].key !== key) {
+            stableOrder = false;
+            break;
+          }
+          seen.add(key);
+        }
+        if (stableOrder) {
+          for (let i = 0; i < prevCount; i++) {
+            const item = newItems[i];
+            const block = prevOrderedBlocks[i];
+            if (block.rawItem !== item) {
+              block.rawItem = item;
+              block.item(item);
+            }
+            if (needsIndex && block.rawIndex !== i) {
+              block.rawIndex = i;
+              block.index(i);
+            }
+          }
+          return;
+        }
+      }
+      newBlocks.clear();
+      nextOrderedBlocks.length = 0;
+      orderedIndexByKey.clear();
+      const createdBlocks = [];
       let appendCandidate = prevCount > 0 && newItems.length >= prevCount;
       const appendedBlocks = [];
+      let mismatchCount = 0;
+      let mismatchFirst = -1;
+      let mismatchSecond = -1;
+      let hasDuplicateKey = false;
       newItems.forEach((item, index) => {
         const key = keyFn(item, index);
         let block = oldBlocks.get(key);
@@ -2453,6 +2594,7 @@ function createFineGrainedKeyedList(getItems, keyFn, renderItem, needsIndex) {
         const position = orderedIndexByKey.get(key);
         if (position !== void 0) {
           appendCandidate = false;
+          hasDuplicateKey = true;
           const prior = nextOrderedBlocks[position];
           if (prior && prior !== resolvedBlock) {
             destroyRoot(prior.root);
@@ -2469,8 +2611,17 @@ function createFineGrainedKeyedList(getItems, keyFn, renderItem, needsIndex) {
               appendCandidate = false;
             }
           }
-          orderedIndexByKey.set(key, nextOrderedBlocks.length);
+          const nextIndex = nextOrderedBlocks.length;
+          orderedIndexByKey.set(key, nextIndex);
           nextOrderedBlocks.push(resolvedBlock);
+          if (mismatchCount < 3 && (nextIndex >= prevCount || prevOrderedBlocks[nextIndex] !== resolvedBlock)) {
+            if (mismatchCount === 0) {
+              mismatchFirst = nextIndex;
+            } else if (mismatchCount === 1) {
+              mismatchSecond = nextIndex;
+            }
+            mismatchCount++;
+          }
         }
         if (appendCandidate && index >= prevCount) {
           appendedBlocks.push(resolvedBlock);
@@ -2511,7 +2662,26 @@ function createFineGrainedKeyedList(getItems, keyFn, renderItem, needsIndex) {
         }
         oldBlocks.clear();
       }
-      if (newBlocks.size > 0 || container.currentNodes.length > 0) {
+      const canReorderInPlace = createdBlocks.length === 0 && oldBlocks.size === 0 && nextOrderedBlocks.length === prevOrderedBlocks.length;
+      let skipReconcile = false;
+      let updateNodeBuffer = true;
+      if (canReorderInPlace && nextOrderedBlocks.length > 0 && !hasDuplicateKey) {
+        if (mismatchCount === 0) {
+          skipReconcile = true;
+          updateNodeBuffer = false;
+        } else if (mismatchCount === 2 && prevOrderedBlocks[mismatchFirst] === nextOrderedBlocks[mismatchSecond] && prevOrderedBlocks[mismatchSecond] === nextOrderedBlocks[mismatchFirst]) {
+          if (reorderBySwap(
+            parent,
+            prevOrderedBlocks[mismatchFirst],
+            prevOrderedBlocks[mismatchSecond]
+          )) {
+            skipReconcile = true;
+          }
+        } else if (reorderByLIS(parent, container.endMarker, prevOrderedBlocks, nextOrderedBlocks)) {
+          skipReconcile = true;
+        }
+      }
+      if (!skipReconcile && (newBlocks.size > 0 || container.currentNodes.length > 0)) {
         const prevNodes = container.currentNodes;
         const nextNodes = container.nextNodes;
         nextNodes.length = 0;
@@ -2526,6 +2696,20 @@ function createFineGrainedKeyedList(getItems, keyFn, renderItem, needsIndex) {
         reconcileArrays(parent, prevNodes, nextNodes);
         container.currentNodes = nextNodes;
         container.nextNodes = prevNodes;
+      } else if (skipReconcile && updateNodeBuffer) {
+        const prevNodes = container.currentNodes;
+        const nextNodes = container.nextNodes;
+        nextNodes.length = 0;
+        nextNodes.push(container.startMarker);
+        for (let i = 0; i < nextOrderedBlocks.length; i++) {
+          const nodes = nextOrderedBlocks[i].nodes;
+          for (let j = 0; j < nodes.length; j++) {
+            nextNodes.push(nodes[j]);
+          }
+        }
+        nextNodes.push(container.endMarker);
+        container.currentNodes = nextNodes;
+        container.nextNodes = prevNodes;
       }
       container.blocks = newBlocks;
       container.nextBlocks = oldBlocks;
@@ -3120,7 +3304,9 @@ function bindEvent(el, eventName, handler, options2) {
         const fn = resolveHandler();
         callEventHandler(fn, args[0], el);
       } catch (err) {
-        handleError(err, { source: "event", eventName }, rootRef);
+        if (!handleError(err, { source: "event", eventName }, rootRef)) {
+          throw err;
+        }
       }
     };
     return () => {