octane 0.1.25 → 0.1.27

package/dist/runtime.js

@@ -100,6 +100,14 @@ function profilePortalComponent(rawBody) {
 function ensureHooks(scope) {
   return scope.hooks ?? (scope.hooks = /* @__PURE__ */ new Map());
 }
+function registerHookCleanup(scope, cleanup) {
+  if (process.env.NODE_ENV !== "production") {
+    if (scope.block.body[HMR] !== void 0) {
+      cleanup[HMR] = true;
+    }
+  }
+  (scope.cleanups ??= []).push(cleanup);
+}
 let nextHookSlot = 0;
 function hookSlots(count) {
   const base = nextHookSlot;
@@ -1176,12 +1184,18 @@ function drainQueue() {
     }
     const crossRenderUpdate = block.crossRenderUpdate;
     block.crossRenderUpdate = false;
+    const hiddenOwner = findHiddenRenderOwner(block, true);
+    let hiddenActivity = null;
+    let hiddenTry = null;
+    if (hiddenOwner !== null) {
+      if (hiddenOwner.__kind === "trySlotSlot") hiddenTry = hiddenOwner;
+      else hiddenActivity = hiddenOwner;
+    }
     try {
       if (block.nestedUpdateError) {
         block.nestedUpdateError = false;
         throw maximumUpdateDepthError();
       }
-      const hiddenTry = findSuspenseHiddenTry(block);
       if (hiddenTry !== null) {
         attemptHiddenReveal(hiddenTry, block.pendingMode ?? "urgent");
         continue;
@@ -1213,6 +1227,8 @@ function drainQueue() {
         while (root.parentBlock !== null) root = root.parentBlock;
         if (root.kind === "root" && !root.disposed) unmountBlock(root);
       }
+    } finally {
+      if (hiddenActivity !== null) rehideActivityAfterDescendantRender(hiddenActivity);
     }
   }
   QUEUE.length = 0;
@@ -2446,7 +2462,7 @@ function unmountScope(scope, detachDom = true) {
     unmountScopeChildrenAndSlots(scope, detachDom);
   });
 }
-function unmountScopeChildrenAndSlots(scope, detachDom) {
+function runScopeCleanups(scope) {
   const c = scope.cleanups;
   if (c !== null)
     for (let i = c.length - 1; i >= 0; i--) {
@@ -2456,6 +2472,12 @@ function unmountScopeChildrenAndSlots(scope, detachDom) {
         reportTeardownError(err);
       }
     }
+}
+function unmountScopeChildrenAndSlots(scope, detachDom) {
+  runScopeCleanups(scope);
+  unmountScopeChildrenAndSlotsOnly(scope, detachDom);
+}
+function unmountScopeChildrenAndSlotsOnly(scope, detachDom) {
   const children = scope.children;
   if (children !== null)
     for (let i = 0, n = children.length; i < n; i++) unmountScope(children[i].scope, detachDom);
@@ -3123,7 +3145,7 @@ function useEffectEvent(fn, slot) {
     s = { impl: fn, active: true };
     ensureHooks(scope).set(slot, s);
     const cell2 = s;
-    (scope.cleanups ??= []).push(() => {
+    registerHookCleanup(scope, () => {
       cell2.active = false;
     });
   } else {
@@ -3205,6 +3227,87 @@ function scopedChildrenAsBody(props) {
   return (_props, scope, extra) => childrenAsBody(props.children)(void 0, scope, extra);
 }
 const CHILDREN_DIALECT_SLOT = /* @__PURE__ */ Symbol("octane.childrenDialect");
+function hasResettableHmrRange(block) {
+  const start = block.startMarker;
+  const end = block.endMarker;
+  if (start === void 0 || end === void 0) return false;
+  if (start === null || end === null) {
+    return start === null && end === null && (block.kind === "root" || block.exclusiveMarkers === true);
+  }
+  if (start !== end) {
+    return start.parentNode === block.parentNode && end.parentNode === block.parentNode;
+  }
+  for (let parent = block.parentBlock; parent !== null; parent = parent.parentBlock) {
+    if (parent.startMarker === start && parent.endMarker === end) return false;
+  }
+  return start.parentNode === block.parentNode;
+}
+function promoteHmrBlockRange(block) {
+  const root = block.startMarker;
+  if (root === null || root !== block.endMarker) return;
+  const parent = block.parentNode;
+  const rangeStart = document.createComment("hmr");
+  const rangeEnd = document.createComment("/hmr");
+  parent.insertBefore(rangeStart, root);
+  parent.insertBefore(rangeEnd, root.nextSibling);
+  block.startMarker = rangeStart;
+  block.endMarker = rangeEnd;
+  block.exclusiveMarkers = false;
+}
+function resetHmrBlock(block) {
+  if (TEARDOWN_DEPTH === 0) {
+    TEARDOWN_HANDLER = findTryHandler(block.parentBlock) ?? rendererRegionTryHandler(block);
+  }
+  TEARDOWN_DEPTH++;
+  let abortedRefs = null;
+  if (!block.mounted) {
+    abortedRefs = [];
+    collectVisibleSubtreeRefs(block, abortedRefs);
+  }
+  try {
+    withRefDetachSuppression(abortedRefs, () => {
+      if (block.deoptNode !== null) detachDeoptTreeRefs(block.deoptNode, null);
+      const cleanups = block.cleanups;
+      let preserved = null;
+      if (cleanups !== null) {
+        for (let i = cleanups.length - 1; i >= 0; i--) {
+          const cleanup = cleanups[i];
+          if (cleanup[HMR] === true) continue;
+          try {
+            runEffectLifecycleCallback(cleanup);
+          } catch (err) {
+            reportTeardownError(err);
+          }
+        }
+        for (let i = 0; i < cleanups.length; i++) {
+          const cleanup = cleanups[i];
+          if (cleanup[HMR] === true) (preserved ??= []).push(cleanup);
+        }
+      }
+      unmountScopeChildrenAndSlotsOnly(block, true);
+      removeRange(
+        block.startMarker !== null ? block.startMarker.nextSibling : block.parentNode.firstChild,
+        block.endMarker
+      );
+      block.children = null;
+      block.cleanups = preserved;
+      block._slots = null;
+      block.refFields = null;
+      block.slots = [];
+      block.deoptNode = null;
+    });
+    const hooks = block.hooks;
+    if (hooks !== null) {
+      for (const value of hooks.values()) {
+        if (value !== null && typeof value === "object" && Object.prototype.hasOwnProperty.call(value, "deps")) {
+          value.deps = void 0;
+        }
+      }
+    }
+  } finally {
+    if (--TEARDOWN_DEPTH === 0) dispatchTeardownErrors();
+  }
+}
 function resetScopeChildren(scope) {
   const block = scope.block;
   if (TEARDOWN_DEPTH === 0) {
@@ -10559,6 +10662,13 @@ function hmr(fn) {
       const nextFn = incomingMeta ? incomingMeta.fn : incoming;
       if (meta.fn.__octaneReturnedOutput !== nextFn.__octaneReturnedOutput)
         return false;
+      for (const b of meta.liveBlocks) {
+        if (b.disposed) {
+          meta.liveBlocks.delete(b);
+          continue;
+        }
+        if (!hasResettableHmrRange(b)) return false;
+      }
       meta.fn = nextFn;
       if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
         __profileComponentSource(wrapper, meta.fn);
@@ -10573,6 +10683,8 @@ function hmr(fn) {
         b.body = wrapper;
         if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
           __profileSchedule(b, "hmr");
+        promoteHmrBlockRange(b);
+        resetHmrBlock(b);
         scheduleRender(b);
       }
       return true;
@@ -10596,8 +10708,63 @@ function setTransitionFallbackTimeout(ms) {
 function getTransitionFallbackTimeout() {
   return TRANSITION_FALLBACK_TIMEOUT_MS;
 }
-const SUSPENSE_HIDDEN_DISPLAYS = /* @__PURE__ */ new WeakMap();
-const SUSPENSE_HIDDEN_TEXTS = /* @__PURE__ */ new WeakMap();
+const HIDDEN_DISPLAYS = /* @__PURE__ */ new WeakMap();
+const HIDDEN_TEXTS = /* @__PURE__ */ new WeakMap();
+function enforceHiddenDisplay(el) {
+  const hidden = HIDDEN_DISPLAYS.get(el);
+  el.style.setProperty(
+    "display",
+    "none",
+    hidden !== void 0 && hidden.importantOwners > 0 ? "important" : ""
+  );
+}
+function retainHiddenDisplay(el, important) {
+  const existing = HIDDEN_DISPLAYS.get(el);
+  if (existing === void 0) {
+    HIDDEN_DISPLAYS.set(el, {
+      owners: 1,
+      importantOwners: important ? 1 : 0,
+      value: el.style.getPropertyValue("display"),
+      priority: el.style.getPropertyPriority("display"),
+      hadStyle: el.hasAttribute("style")
+    });
+  } else {
+    existing.owners++;
+    if (important) existing.importantOwners++;
+  }
+  enforceHiddenDisplay(el);
+}
+function releaseHiddenDisplay(el, important) {
+  const display = HIDDEN_DISPLAYS.get(el);
+  if (display === void 0) return;
+  if (important) display.importantOwners--;
+  if (--display.owners === 0) {
+    HIDDEN_DISPLAYS.delete(el);
+    if (display.value === "") el.style.removeProperty("display");
+    else el.style.setProperty("display", display.value, display.priority);
+    if (!display.hadStyle && el.getAttribute("style") === "") el.removeAttribute("style");
+  } else {
+    enforceHiddenDisplay(el);
+  }
+}
+function enforceHiddenText(text) {
+  if (text.data !== "") text.data = "";
+}
+function retainHiddenText(text) {
+  const existing = HIDDEN_TEXTS.get(text);
+  if (existing === void 0) HIDDEN_TEXTS.set(text, { owners: 1, data: text.data });
+  else existing.owners++;
+}
+function releaseHiddenText(text) {
+  const saved = HIDDEN_TEXTS.get(text);
+  if (saved === void 0) return;
+  if (--saved.owners === 0) {
+    HIDDEN_TEXTS.delete(text);
+    text.data = saved.data;
+  } else {
+    enforceHiddenText(text);
+  }
+}
 function setTryBranch(slot, next) {
   slot.branch = next;
   if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__) {
@@ -10959,31 +11126,17 @@ function hideBlockHostRange(block, hidden) {
       const el = node;
       if (!hidden.displays.has(el)) {
         hidden.displays.add(el);
-        const existing = SUSPENSE_HIDDEN_DISPLAYS.get(el);
-        if (existing === void 0) {
-          SUSPENSE_HIDDEN_DISPLAYS.set(el, {
-            owners: 1,
-            value: el.style.getPropertyValue("display"),
-            priority: el.style.getPropertyPriority("display"),
-            hadStyle: el.hasAttribute("style")
-          });
-        } else {
-          existing.owners++;
-        }
+        retainHiddenDisplay(el, true);
+      } else {
+        enforceHiddenDisplay(el);
       }
-      el.style.setProperty("display", "none", "important");
     } else if (node.nodeType === 3) {
       const text = node;
       if (!hidden.texts.has(text)) {
         hidden.texts.add(text);
-        const existing = SUSPENSE_HIDDEN_TEXTS.get(text);
-        if (existing === void 0) {
-          SUSPENSE_HIDDEN_TEXTS.set(text, { owners: 1, data: text.data });
-        } else {
-          existing.owners++;
-        }
+        retainHiddenText(text);
       }
-      if (text.data !== "") text.data = "";
+      enforceHiddenText(text);
     }
     node = node.nextSibling;
   }
@@ -11011,26 +11164,10 @@ function showTryBlock(state) {
   if (hidden === null) return;
   state.hiddenDom = null;
   for (const el of hidden.displays) {
-    const display = SUSPENSE_HIDDEN_DISPLAYS.get(el);
-    if (display === void 0) continue;
-    if (--display.owners === 0) {
-      SUSPENSE_HIDDEN_DISPLAYS.delete(el);
-      if (display.value === "") el.style.removeProperty("display");
-      else el.style.setProperty("display", display.value, display.priority);
-      if (!display.hadStyle && el.getAttribute("style") === "") el.removeAttribute("style");
-    } else {
-      el.style.setProperty("display", "none", "important");
-    }
+    releaseHiddenDisplay(el, true);
   }
   for (const text of hidden.texts) {
-    const saved = SUSPENSE_HIDDEN_TEXTS.get(text);
-    if (saved === void 0) continue;
-    if (--saved.owners === 0) {
-      SUSPENSE_HIDDEN_TEXTS.delete(text);
-      text.data = saved.data;
-    } else if (text.data !== "") {
-      text.data = "";
-    }
+    releaseHiddenText(text);
   }
 }
 function releaseHeldTransition(state) {
@@ -11182,6 +11319,7 @@ function commitResume(state) {
 }
 function commitResumeInner(state) {
   if (state.parentBlock.disposed) return;
+  const hiddenActivity = findHiddenActivity(state.parentBlock);
   const wasHeld = state.transitionHeld;
   if (wasHeld) state.transitionHeld = false;
   HELD_TRANSITIONS.delete(state);
@@ -11273,14 +11411,33 @@ function commitResumeInner(state) {
     }
     if (!deferringStagedRevealEffects) commitEffects();
   } finally {
+    if (hiddenActivity !== null) rehideActivityAfterDescendantRender(hiddenActivity);
     if (wasHeld) tickTransitionCount(-1);
   }
 }
-function findSuspenseHiddenTry(block) {
+function findHiddenRenderOwner(block, includeActivity) {
+  let activity = null;
   for (let p = block; p !== null; p = p.parentBlock) {
+    if (includeActivity && activity === null && p.inactive) {
+      const candidate = p.__activitySlot;
+      if (candidate !== void 0 && candidate.block === p && candidate.hidden) {
+        activity = candidate;
+      }
+    }
     const slot = p.__trySlot;
     if (slot !== void 0 && slot.tryBlock === p && slot.hiddenDom !== null) return slot;
   }
+  return activity;
+}
+function findSuspenseHiddenTry(block) {
+  return findHiddenRenderOwner(block, false);
+}
+function findHiddenActivity(block) {
+  for (let p = block; p !== null; p = p.parentBlock) {
+    if (!p.inactive) continue;
+    const candidate = p.__activitySlot;
+    if (candidate !== void 0 && candidate.block === p && candidate.hidden) return candidate;
+  }
   return null;
 }
 function snapshotSubtreeEffectDeps(scope) {
@@ -11396,11 +11553,19 @@ function queueCurrentHiddenRefs(state) {
   }
 }
 function attemptHiddenReveal(state, scheduledMode) {
+  const hiddenActivity = findHiddenActivity(state.tryBlock);
+  try {
+    attemptHiddenRevealInner(state, scheduledMode);
+  } finally {
+    if (hiddenActivity !== null) rehideActivityAfterDescendantRender(hiddenActivity);
+  }
+}
+function attemptHiddenRevealInner(state, scheduledMode) {
   const tryBlock2 = state.tryBlock;
   if (tryBlock2 === null || tryBlock2.disposed || state.hiddenDom === null) return;
   const hiddenAncestor = findSuspenseHiddenTry(tryBlock2.parentBlock);
   if (hiddenAncestor !== null) {
-    attemptHiddenReveal(hiddenAncestor, scheduledMode);
+    attemptHiddenRevealInner(hiddenAncestor, scheduledMode);
     return;
   }
   STAGED_REVEALS.delete(state);
@@ -11684,7 +11849,7 @@ function useTransition(slot) {
       }
     };
     TRANSITION_LISTENERS.add(listener);
-    (scope.cleanups ??= []).push(() => TRANSITION_LISTENERS.delete(listener));
+    registerHookCleanup(scope, () => TRANSITION_LISTENERS.delete(listener));
   }
   return [s.isPending, s.start];
 }
@@ -11786,7 +11951,7 @@ function useFormStatus(slot) {
     s = { form: null, listener: null };
     const slotRef = s;
     ensureHooks(scope).set(slot, slotRef);
-    (scope.cleanups ??= []).push(() => {
+    registerHookCleanup(scope, () => {
       if (slotRef.form && slotRef.listener)
         FORM_STATUS_LISTENERS.get(slotRef.form)?.delete(slotRef.listener);
     });
@@ -11861,7 +12026,7 @@ function useOptimistic(passthrough, updateFnOrSlot, slot) {
       if (TRANSITION_PENDING_COUNT === 0 && slotRef.armed) clear();
     };
     TRANSITION_LISTENERS.add(listener);
-    (scope.cleanups ??= []).push(() => TRANSITION_LISTENERS.delete(listener));
+    registerHookCleanup(scope, () => TRANSITION_LISTENERS.delete(listener));
   }
   s.updateFn = updateFn;
   let optimistic = passthrough;
@@ -12388,25 +12553,49 @@ function ifBlock(parentScope, slotKey, domParent, cond, thenBody, elseBody, anch
 function hideActivityRange(state) {
   const b = state.block;
   if (!b) return;
+  for (const el of state.hiddenDisplays) {
+    if (el.parentNode !== b.parentNode) {
+      state.hiddenDisplays.delete(el);
+      releaseHiddenDisplay(el, false);
+    }
+  }
+  for (const text of state.hiddenTexts) {
+    if (text.parentNode !== b.parentNode) {
+      state.hiddenTexts.delete(text);
+      releaseHiddenText(text);
+    }
+  }
   let node = b.startMarker.nextSibling;
   while (node && node !== b.endMarker) {
     if (node.nodeType === 1) {
       const el = node;
-      if (!state.savedDisplay.has(el)) state.savedDisplay.set(el, el.style.display);
-      el.style.display = "none";
+      if (!state.hiddenDisplays.has(el)) {
+        state.hiddenDisplays.add(el);
+        retainHiddenDisplay(el, false);
+      } else {
+        enforceHiddenDisplay(el);
+      }
     } else if (node.nodeType === 3) {
       const t = node;
-      if (!state.savedText.has(t)) state.savedText.set(t, t.nodeValue ?? "");
-      if (t.nodeValue !== "") t.nodeValue = "";
+      if (!state.hiddenTexts.has(t)) {
+        state.hiddenTexts.add(t);
+        retainHiddenText(t);
+      }
+      enforceHiddenText(t);
     }
     node = node.nextSibling;
   }
 }
+function rehideActivityAfterDescendantRender(state) {
+  const b = state.block;
+  if (b === null || !state.hidden || state.deactivationPending || blockSubtreeDisposed(b)) return;
+  hideActivityRange(state);
+}
 function showActivityRange(state) {
-  for (const [el, display] of state.savedDisplay) el.style.display = display;
-  state.savedDisplay.clear();
-  for (const [t, data] of state.savedText) t.nodeValue = data;
-  state.savedText.clear();
+  for (const el of state.hiddenDisplays) releaseHiddenDisplay(el, false);
+  state.hiddenDisplays.clear();
+  for (const text of state.hiddenTexts) releaseHiddenText(text);
+  state.hiddenTexts.clear();
 }
 function queueActivityDeactivation(state, block, commitVersion) {
   enqueueEffectEventCommitAction(() => {
@@ -12456,9 +12645,10 @@ function activityBlock(parentScope, slotKey, domParent, mode, body, anchor, env)
       hidden: false,
       commitVersion: 0,
       deactivationPending: false,
-      savedDisplay: /* @__PURE__ */ new Map(),
-      savedText: /* @__PURE__ */ new Map()
+      hiddenDisplays: /* @__PURE__ */ new Set(),
+      hiddenTexts: /* @__PURE__ */ new Set()
     };
+    b2.__activitySlot = state;
     parentScope.slots[slotKey] = state;
     registerSlot(parentScope, state);
     const adopted = open !== null;

package/dist/universal-core.d.ts

@@ -611,6 +611,7 @@ export interface ObjectHostInstance {
 }
 interface ObjectDriverState {
     instances: Map<number, ObjectHostInstance>;
+    parents: Map<number, number | null>;
     events: Map<number, Map<string, UniversalEventListenerDescriptor>>;
     lifecycles: Map<number, Map<string, UniversalListenerDescriptor>>;
     localCallbacks: Map<number, Map<string, UniversalListenerDescriptor>>;