@fictjs/runtime 0.0.10 → 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;
@@ -305,6 +305,11 @@ var lowPriorityQueue = [];
 var enqueueMicrotask = typeof queueMicrotask === "function" ? queueMicrotask : (fn) => {
   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;
@@ -428,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;
@@ -512,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;
@@ -550,7 +567,15 @@ function updateComputed(c) {
 }
 function runEffect(e) {
   const flags = e.flags;
-  if (flags & Dirty || flags & Pending && e.deps && checkDirty(e.deps, e)) {
+  if (flags & Dirty) {
+    if (e.runCleanup) {
+      inCleanup = true;
+      try {
+        e.runCleanup();
+      } finally {
+        inCleanup = false;
+      }
+    }
     ++cycle;
     effectRunDevtools(e);
     e.depsTail = void 0;
@@ -567,6 +592,35 @@ function runEffect(e) {
       e.flags = Watching;
       throw err;
     }
+  } else if (flags & Pending && e.deps) {
+    if (e.runCleanup) {
+      inCleanup = true;
+      try {
+        e.runCleanup();
+      } finally {
+        inCleanup = false;
+      }
+    }
+    if (checkDirty(e.deps, e)) {
+      ++cycle;
+      effectRunDevtools(e);
+      e.depsTail = void 0;
+      e.flags = WatchingRunning;
+      const prevSub = activeSub;
+      activeSub = e;
+      try {
+        e.fn();
+        activeSub = prevSub;
+        e.flags = Watching;
+        purgeDeps(e);
+      } catch (err) {
+        activeSub = prevSub;
+        e.flags = Watching;
+        throw err;
+      }
+    } else {
+      e.flags = Watching;
+    }
   } else {
     e.flags = Watching;
   }
@@ -645,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) {
@@ -662,7 +718,7 @@ function signalOper(value) {
     return;
   }
   const flags = this.flags;
-  if (flags & Dirty) {
+  if (flags & Dirty && !inCleanup) {
     if (updateSignal(this)) {
       const subs = this.subs;
       if (subs !== void 0) shallowPropagate(subs);
@@ -690,6 +746,7 @@ function computed(getter) {
     getter
   };
   const bound = computedOper.bind(c);
+  bound[COMPUTED_MARKER] = true;
   return bound;
 }
 function computedOper() {
@@ -742,7 +799,35 @@ 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 = {
+    fn,
+    subs: void 0,
+    subsTail: void 0,
+    deps: void 0,
+    depsTail: void 0,
+    flags: WatchingRunning,
+    runCleanup: cleanupRunner,
+    __id: void 0
+  };
+  registerEffectDevtools(e);
+  const prevSub = activeSub;
+  if (prevSub !== void 0) link(e, prevSub, 0);
+  activeSub = e;
+  try {
+    effectRunDevtools(e);
+    fn();
+  } finally {
+    activeSub = prevSub;
+    e.flags &= ~Running;
+  }
+  const disposer = effectOper.bind(e);
+  disposer[EFFECT_MARKER] = true;
+  return disposer;
 }
 function effectOper() {
   disposeNode(this);
@@ -757,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);
@@ -858,8 +945,11 @@ function createMemo(fn) {
 function createEffect(fn) {
   let cleanups = [];
   const rootForError = getCurrentRoot();
-  const run = () => {
+  const doCleanup = () => {
     runCleanupList(cleanups);
+    cleanups = [];
+  };
+  const run = () => {
     const bucket = [];
     withEffectCleanups(bucket, () => {
       try {
@@ -876,7 +966,7 @@ function createEffect(fn) {
     });
     cleanups = bucket;
   };
-  const disposeEffect = effect(run);
+  const disposeEffect = effectWithCleanup(run, doCleanup);
   const teardown = () => {
     runCleanupList(cleanups);
     disposeEffect();
@@ -887,11 +977,13 @@ function createEffect(fn) {
 function createRenderEffect(fn) {
   let cleanup;
   const rootForError = getCurrentRoot();
-  const run = () => {
+  const doCleanup = () => {
     if (cleanup) {
       cleanup();
       cleanup = void 0;
     }
+  };
+  const run = () => {
     try {
       const maybeCleanup = fn();
       if (typeof maybeCleanup === "function") {
@@ -905,7 +997,7 @@ function createRenderEffect(fn) {
       throw err;
     }
   };
-  const disposeEffect = effect(run);
+  const disposeEffect = effectWithCleanup(run, doCleanup);
   const teardown = () => {
     if (cleanup) {
       cleanup();
@@ -1437,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);
@@ -1720,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);
       });
@@ -1728,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;
       });
@@ -2139,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];
@@ -2202,6 +2291,7 @@ function removeBlockRange(block) {
     cursor = next;
   }
 }
+var MAX_SAFE_VERSION = 9007199254740991;
 function createVersionedSignalAccessor(initialValue) {
   let current = initialValue;
   let version = 0;
@@ -2212,7 +2302,7 @@ function createVersionedSignalAccessor(initialValue) {
       return current;
     }
     current = value;
-    version++;
+    version = version >= MAX_SAFE_VERSION ? 1 : version + 1;
     track(version);
   }
   return accessor;
@@ -2268,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);
@@ -2295,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);
@@ -2327,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) {
@@ -2353,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);
@@ -2386,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);
@@ -2402,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);
@@ -2444,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;
@@ -2459,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;
@@ -3053,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 () => {