@b9g/crank 0.7.1 → 0.7.3

package/umd.js

@@ -510,6 +510,7 @@
 	const IsInForAwaitOfLoop = 1 << 14;
 	const NeedsToYield = 1 << 15;
 	const PropsAvailable = 1 << 16;
+	const IsSchedulingRefresh = 1 << 17;
 	function getFlag(ret, flag) {
 	    return !!(ret.f & flag);
 	}
@@ -863,10 +864,10 @@
 	                    }
 	                }
 	                else if (ret) {
+	                    let candidateFound = false;
 	                    // we do not need to add the retainer to the graveyard if it is the
 	                    // fallback of another retainer
 	                    // search for the tag in fallback chain
-	                    let candidateFound = false;
 	                    for (let predecessor = ret, candidate = ret.fallback; candidate; predecessor = candidate, candidate = candidate.fallback) {
 	                        if (candidate.el.tag === child.tag) {
 	                            // If we find a retainer in the fallback chain with the same tag,
@@ -1701,6 +1702,9 @@
 	                });
 	            }
 	        }
+	        if (getFlag(ctx.ret, IsScheduling)) {
+	            setFlag(ctx.ret, IsSchedulingRefresh);
+	        }
 	        let diff;
 	        const schedulePromises = [];
 	        try {
@@ -2046,10 +2050,11 @@
 	        if (getFlag(ctx.ret, IsInForOfLoop) &&
 	            !getFlag(ctx.ret, NeedsToYield) &&
 	            !getFlag(ctx.ret, IsUnmounted) &&
-	            !getFlag(ctx.ret, IsScheduling)) {
+	            !getFlag(ctx.ret, IsSchedulingRefresh)) {
 	            console.error(`Component <${getTagName(ctx.ret.el.tag)}> yielded/returned more than once in for...of loop`);
 	        }
 	        setFlag(ctx.ret, NeedsToYield, false);
+	        setFlag(ctx.ret, IsSchedulingRefresh, false);
 	        if (iteration.done) {
 	            setFlag(ctx.ret, IsSyncGen, false);
 	            ctx.iterator = undefined;
@@ -2095,11 +2100,12 @@
 	                    if (getFlag(ctx.ret, IsInForOfLoop) &&
 	                        !getFlag(ctx.ret, NeedsToYield) &&
 	                        !getFlag(ctx.ret, IsUnmounted) &&
-	                        !getFlag(ctx.ret, IsScheduling)) {
+	                        !getFlag(ctx.ret, IsSchedulingRefresh)) {
 	                        console.error(`Component <${getTagName(ctx.ret.el.tag)}> yielded/returned more than once in for...of loop`);
 	                    }
 	                }
 	                setFlag(ctx.ret, NeedsToYield, false);
+	                setFlag(ctx.ret, IsSchedulingRefresh, false);
 	                if (iteration.done) {
 	                    setFlag(ctx.ret, IsAsyncGen, false);
 	                    ctx.iterator = undefined;
@@ -2331,18 +2337,17 @@
 	        });
 	        return getValue(ctx.ret);
 	    }
-	    const wasScheduling = getFlag(ctx.ret, IsScheduling);
 	    const values = commitChildren(ctx.adapter, ctx.host, ctx, ctx.scope, ctx.ret, ctx.index, schedulePromises, hydrationNodes);
 	    if (getFlag(ctx.ret, IsUnmounted)) {
 	        return;
 	    }
 	    addEventTargetDelegates(ctx.ctx, values);
 	    // Execute schedule callbacks early to check for async deferral
-	    const callbacks = scheduleMap.get(ctx);
+	    const wasScheduling = getFlag(ctx.ret, IsScheduling);
 	    let schedulePromises1;
+	    const callbacks = scheduleMap.get(ctx);
 	    if (callbacks) {
 	        scheduleMap.delete(ctx);
-	        // TODO: think about error handling for schedule callbacks
 	        setFlag(ctx.ret, IsScheduling);
 	        const result = ctx.adapter.read(unwrap(values));
 	        for (const callback of callbacks) {
@@ -2353,7 +2358,7 @@
 	        }
 	        if (schedulePromises1 && !getFlag(ctx.ret, DidCommit)) {
 	            const scheduleCallbacksP = Promise.all(schedulePromises1).then(() => {
-	                setFlag(ctx.ret, IsScheduling, false);
+	                setFlag(ctx.ret, IsScheduling, wasScheduling);
 	                propagateComponent(ctx);
 	                if (ctx.ret.fallback) {
 	                    unmount(ctx.adapter, ctx.host, ctx.parent, ctx.ret.fallback, false);
@@ -2393,6 +2398,37 @@
 	    // if schedule callbacks call refresh() or async mounting is happening.
 	    return getValue(ctx.ret, true);
 	}
+	/**
+	 * Checks if a target retainer is active (contributing) in the host's retainer tree.
+	 * Performs a downward traversal from host to find if target is in the active path.
+	 */
+	function isRetainerActive(target, host) {
+	    const stack = [host];
+	    while (stack.length > 0) {
+	        const current = stack.pop();
+	        if (current === target) {
+	            return true;
+	        }
+	        // Add direct children to stack (skip if this is a host boundary)
+	        // Host boundaries are: DOM elements (string tags) or Portal, but NOT Fragment
+	        const isHostBoundary = current !== host &&
+	            ((typeof current.el.tag === "string" && current.el.tag !== Fragment) ||
+	                current.el.tag === Portal);
+	        if (current.children && !isHostBoundary) {
+	            const children = wrap(current.children);
+	            for (const child of children) {
+	                if (child) {
+	                    stack.push(child);
+	                }
+	            }
+	        }
+	        // Add fallback chains (only if current retainer is using fallback)
+	        if (current.fallback && !getFlag(current, DidDiff)) {
+	            stack.push(current.fallback);
+	        }
+	    }
+	    return false;
+	}
 	/**
 	 * Propagates component changes up to ancestors when rendering starts from a
 	 * component via refresh() or multiple for await...of renders. This handles
@@ -2403,14 +2439,20 @@
 	    const values = getChildValues(ctx.ret, ctx.index);
 	    addEventTargetDelegates(ctx.ctx, values, (ctx1) => ctx1[_ContextState].host === ctx.host);
 	    const host = ctx.host;
+	    const initiator = ctx.ret;
+	    // Check if initiator is active in the host's tree
+	    if (!isRetainerActive(initiator, host)) {
+	        return;
+	    }
 	    const props = stripSpecialProps(host.el.props);
+	    const hostChildren = getChildValues(host, 0);
 	    ctx.adapter.arrange({
 	        tag: host.el.tag,
 	        tagName: getTagName(host.el.tag),
 	        node: host.value,
 	        props,
 	        oldProps: props,
-	        children: getChildValues(host, 0),
+	        children: hostChildren,
 	    });
 	    flush(ctx.adapter, ctx.root, ctx);
 	}
@@ -2981,7 +3023,22 @@
 	                        !(typeof value === "string" &&
 	                            typeof element[name] === "boolean") &&
 	                        isWritableProperty(element, name)) {
-	                        if (element[name] !== value || oldValue === undefined) {
+	                        // For URL properties like src and href, the DOM property returns the
+	                        // resolved absolute URL. We need to resolve the prop value the same way
+	                        // to compare correctly.
+	                        let domValue = element[name];
+	                        let propValue = value;
+	                        if ((name === "src" || name === "href") &&
+	                            typeof value === "string" &&
+	                            typeof domValue === "string") {
+	                            try {
+	                                propValue = new URL(value, element.baseURI).href;
+	                            }
+	                            catch {
+	                                // Invalid URL, use original value for comparison
+	                            }
+	                        }
+	                        if (propValue !== domValue || oldValue === undefined) {
 	                            if (isHydrating &&
 	                                typeof element[name] === "string" &&
 	                                element[name] !== value) {