@depict-ai/ui 1.1.4 → 1.1.5

package/dist/client/main.cjs

@@ -43,7 +43,7 @@ $parcel$export(module.exports, "defaultGridSpacing", () => $a3280f0aad997933$exp
 $parcel$export(module.exports, "defaultColsAtSize", () => $a3280f0aad997933$export$c3834fa86c616831);
 $parcel$export(module.exports, "defaultCategoryTitlePlugin", () => $a3280f0aad997933$export$7bf543b9d9be2c22);
 $parcel$export(module.exports, "version", () => $b757f75811f3261f$export$83d89fbfd8236492);
-/*! Depict.ai search and product listing SDK */ const $b757f75811f3261f$export$83d89fbfd8236492 = "1.1.4";
+/*! Depict.ai search and product listing SDK */ const $b757f75811f3261f$export$83d89fbfd8236492 = "1.1.5";
 
 
 
@@ -309,7 +309,7 @@ class $e1d6c0f3d89d531c$export$e015ed2f2950f2e3 {
                 if (this.#supports_finalization_registry) cache_obj.finalization_registry_.register(result, body); // delete key from cache when value (WeakRefs) are collected
                 else // delete things from cache after 5 minutes, so it doesn't get too heavy
                 setTimeout((0, $57o7A$depictaiutilishared.catchify)(()=>delete cache_obj.cache_[body]), 300000);
-            }), 30000 // cache values for at least 30 seconds
+            }), 60000 // cache values for at least 60 seconds
             );
             return result;
         } finally{
@@ -1189,6 +1189,7 @@ function $ac167f6af6a48fc3$export$a1fd619a4743ca08({ plp_results_: plp_results_
             const record = records[i];
             const { target: target , intersectionRatio: intersectionRatio  } = record;
             const index_of_target = target_to_index_map.get(target);
+            if (index_of_target == undefined) return; // It seems like it can happen that we get IntersectionObserverEntries after the onCleanup function for a recommendation card has run, in Firefox. Probably a bug in Firefox? If I understood the bug correctly, this is a workaround.
             const is_in_set = currently_intersecting.has(index_of_target);
             if (intersectionRatio > 0) {
                 if (!is_in_set) currently_intersecting.add(index_of_target);
@@ -5108,23 +5109,30 @@ function $276380e4607fb9fb$export$6e49da55e449af7c({ scroll_restoration_data_: [
         ]); // get rid of old data the browser saves the old state and will restore it later on
     };
     (0, $57o7A$solidjs.createComputed)((0, $57o7A$depictaiutilishared.catchify)(()=>{
-        const r = get_last_result_in_viewport_();
-        if (r == undefined || r <= 0 || r == Infinity) return;
+        const last_result = get_last_result_in_viewport_();
+        if (last_result == undefined || last_result <= 0 || last_result == Infinity) return;
+        if (isNaN(last_result)) {
+            // if last_result is NaN there's an issue somewhere, but if we store something here that's not a number the for loop further down will break, and we won't be able to load results at all, so let's just continue
+            (0, $57o7A$depictaiutilishared.report)(new Error("last_result is NaN, this should not happen"), "error", {
+                last_result: last_result
+            });
+            return;
+        }
         // We can push to history.state max 100 times per 30 seconds (Safari) so we have to debounce/cap this at 300ms for aggressive scrolling.
         // Pushing to history.state right before we leave the page (onunload etc.) is unreliable, as it has to occur *before* the next page is pushed to history.
-        // Instead we delay our push with a timeout set to the next acceptable interval to the previous one, when necessary
+        // Instead, we delay our push with a timeout set to the next acceptable interval to the previous one, when necessary
         const now = +new Date();
         const time_since_last_ran = now - last_time_history_changed;
         if (time_since_last_ran > $276380e4607fb9fb$var$max_history_change_frequency) {
             // If the interval to the previous push is already long enough, it's fine to push the next value directly.
-            set_min_results_loaded(r);
+            set_min_results_loaded(last_result);
             last_time_history_changed = now;
             // Even though the interval has passed, there could still be a delayed push timeout in flight (browser can delay timeouts at will).
             // We've already written the guaranteed-to-be-freshest value so we can just cancel it.
             clearTimeout(timeout);
             return;
         }
-        set_to_later = r;
+        set_to_later = last_result;
         // If a delayed push timeout is already running, just changing the value that will be pushed is sufficient
         if (timeout) return;
         timeout = setTimeout((0, $57o7A$depictaiutilishared.catchify)(()=>{