@adventurelabs/scout-core 1.5.4 → 2.0.0

package/dist/helpers/users.queries.d.ts

@@ -1,5 +1,13 @@
 import { SupabaseClient } from "@supabase/supabase-js";
-import { IUserAndRole } from "../types/db";
+import { IUser, IUserAndRole, IUserProfileRow, IUserRolePerHerd } from "../types/db";
 import { Database } from "../types/supabase";
 import { IWebResponseCompatible } from "../types/requests";
+export type UserProfileUpdate = Database["public"]["Tables"]["users"]["Update"];
+export declare function get_user_roles_query(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IUserRolePerHerd[]>>;
+export declare function get_user_query(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IUser | null>>;
+export declare function get_users_with_herd_access_query(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IUserAndRole[]>>;
 export declare function get_users_with_herd_access_batch_query(client: SupabaseClient<Database>, herd_ids: number[]): Promise<IWebResponseCompatible<Record<number, IUserAndRole[]>>>;
+export declare function upsert_user_herd_role_query(client: SupabaseClient<Database>, herd_id: number, username: string, herd_role_id: number): Promise<IWebResponseCompatible<IUserAndRole | null>>;
+export declare function update_user_profile_query(client: SupabaseClient<Database>, user_id: string, patch: UserProfileUpdate): Promise<IWebResponseCompatible<IUserProfileRow | null>>;
+export declare function leave_herd_for_current_user_query(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IUserRolePerHerd | null>>;
+export declare function remove_user_from_herd_for_admin_query(client: SupabaseClient<Database>, herd_id: number, user_id: string): Promise<IWebResponseCompatible<IUserRolePerHerd | null>>;

package/dist/helpers/users.queries.js

@@ -1,4 +1,42 @@
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_user_roles_query(client, herd_id) {
+    const { data } = await client
+        .from("users_roles_per_herd")
+        .select("*")
+        .eq("herd_id", herd_id);
+    if (!data) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: `No user role found for herd ${herd_id}`,
+            data: null,
+        };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function get_user_query(client) {
+    const { data } = await client.auth.getUser();
+    const new_user = data.user;
+    return IWebResponse.success(new_user).to_compatible();
+}
+export async function get_users_with_herd_access_query(client, herd_id) {
+    const { data, error } = await client
+        .from("users_roles_per_herd")
+        .select(`
+      herd_role_id,
+      herd_roles (*),
+      users!users_roles_per_herd_user_id_fkey (*)
+    `)
+        .eq("herd_id", herd_id);
+    if (error) {
+        return { status: EnumWebResponse.ERROR, msg: error.message, data: null };
+    }
+    const transformedData = (data ?? []).map((item) => ({
+        user: item.users,
+        herd_role_id: item.herd_role_id,
+        herd_role: item.herd_roles,
+    }));
+    return IWebResponse.success(transformedData).to_compatible();
+}
 export async function get_users_with_herd_access_batch_query(client, herd_ids) {
     var _a;
     if (herd_ids.length === 0) {
@@ -28,3 +66,72 @@ export async function get_users_with_herd_access_batch_query(client, herd_ids) {
     }
     return IWebResponse.success(grouped).to_compatible();
 }
+export async function upsert_user_herd_role_query(client, herd_id, username, herd_role_id) {
+    const { data: user, error: user_error } = await client
+        .from("users")
+        .select("*")
+        .eq("username", username)
+        .single();
+    if (user_error) {
+        return IWebResponse.error("Unable to fetch user with provided username").to_compatible();
+    }
+    if (!user) {
+        return IWebResponse.error("User not found").to_compatible();
+    }
+    const { data: herdRole, error: role_error } = await client
+        .from("herd_roles")
+        .select("*")
+        .eq("id", herd_role_id)
+        .eq("herd_id", herd_id)
+        .single();
+    if (role_error || !herdRole) {
+        return IWebResponse.error("Invalid herd role for this herd").to_compatible();
+    }
+    const { error } = await client.from("users_roles_per_herd").upsert({
+        user_id: user.id,
+        herd_id,
+        herd_role_id,
+    });
+    if (error) {
+        return IWebResponse.error("Unable to update or add user with provided username. Ensure you have sufficient permissions.").to_compatible();
+    }
+    return IWebResponse.success({
+        user,
+        herd_role_id,
+        herd_role: herdRole,
+    }).to_compatible();
+}
+export async function update_user_profile_query(client, user_id, patch) {
+    const { data, error } = await client
+        .from("users")
+        .update(patch)
+        .eq("id", user_id)
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("User not found or profile update failed").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function leave_herd_for_current_user_query(client, herd_id) {
+    const { data, error } = await client.rpc("leave_herd_for_current_user", {
+        p_herd_id: herd_id,
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function remove_user_from_herd_for_admin_query(client, herd_id, user_id) {
+    const { data, error } = await client.rpc("remove_user_from_herd_for_admin", {
+        p_herd_id: herd_id,
+        p_user_id: user_id,
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/versions_software.d.ts

@@ -1,9 +1,11 @@
 import { Database } from "../types/supabase";
-import { IVersionsSoftware, VersionsSoftwareInsert } from "../types/db";
+import { IVersionsSoftware, IVersionsSoftwareWithBuildUrl, VersionsSoftwareInsert } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
 import { SupabaseClient } from "@supabase/supabase-js";
 export declare function get_versions_software(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IVersionsSoftware[]>>;
 export declare function get_versions_software_by_system(client: SupabaseClient<Database>, system: string): Promise<IWebResponseCompatible<IVersionsSoftware[]>>;
+export declare function get_versions_software_with_build_urls(client: SupabaseClient<Database>): Promise<IWebResponseCompatible<IVersionsSoftwareWithBuildUrl[]>>;
+export declare function get_versions_software_by_system_with_build_urls(client: SupabaseClient<Database>, system: string): Promise<IWebResponseCompatible<IVersionsSoftwareWithBuildUrl[]>>;
 export declare function create_version_software(client: SupabaseClient<Database>, newVersionSoftware: VersionsSoftwareInsert): Promise<IWebResponseCompatible<IVersionsSoftware | null>>;
 export declare function update_version_software(client: SupabaseClient<Database>, version_id: number, updatedVersionSoftware: Partial<VersionsSoftwareInsert>): Promise<IWebResponseCompatible<IVersionsSoftware | null>>;
 export declare function delete_version_software(client: SupabaseClient<Database>, version_id: number): Promise<IWebResponseCompatible<IVersionsSoftware | null>>;

package/dist/helpers/versions_software.js

@@ -1,4 +1,14 @@
 import { IWebResponse } from "../types/requests";
+import { createSignedUrlMap } from "./media_urls";
+async function attachBuildArtifactUrls(client, versions) {
+    const urlsByPath = await createSignedUrlMap(client, versions.map((version) => version.path_build_artifact));
+    return versions.map((version) => ({
+        ...version,
+        build_artifact_url: version.path_build_artifact
+            ? urlsByPath.get(version.path_build_artifact) ?? null
+            : null,
+    }));
+}
 export async function get_versions_software(client) {
     const { data, error } = await client
         .from("versions_software")
@@ -26,6 +36,20 @@ export async function get_versions_software_by_system(client, system) {
     }
     return IWebResponse.success(data).to_compatible();
 }
+export async function get_versions_software_with_build_urls(client) {
+    const response = await get_versions_software(client);
+    if (!response.data) {
+        return IWebResponse.error(response.msg ?? "No software versions found").to_compatible();
+    }
+    return IWebResponse.success(await attachBuildArtifactUrls(client, response.data)).to_compatible();
+}
+export async function get_versions_software_by_system_with_build_urls(client, system) {
+    const response = await get_versions_software_by_system(client, system);
+    if (!response.data) {
+        return IWebResponse.error(response.msg ?? `No software versions found for system: ${system}`).to_compatible();
+    }
+    return IWebResponse.success(await attachBuildArtifactUrls(client, response.data)).to_compatible();
+}
 export async function create_version_software(client, newVersionSoftware) {
     const { data, error } = await client
         .from("versions_software")

package/dist/helpers/versions_software_server.d.ts

@@ -1,4 +1,83 @@
-import { IVersionsSoftwareWithBuildUrl } from "../types/db";
-import { IWebResponseCompatible } from "../types/requests";
-export declare function server_get_versions_software(): Promise<IWebResponseCompatible<IVersionsSoftwareWithBuildUrl[]>>;
-export declare function server_get_versions_software_by_system(system: string): Promise<IWebResponseCompatible<IVersionsSoftwareWithBuildUrl[]>>;
+import { VersionsSoftwareInsert } from "../types/db";
+export declare function server_get_versions_software(): Promise<import("../types").IWebResponseCompatible<{
+    broken: boolean;
+    commit_hash: string | null;
+    created_at: string;
+    description: string;
+    hyperlink: string | null;
+    id: number;
+    min: boolean;
+    path_build_artifact: string | null;
+    pre: boolean;
+    stable: boolean;
+    system: string;
+    title: string | null;
+    updated_at: string | null;
+    version: string;
+}[]>>;
+export declare function server_get_versions_software_by_system(system: string): Promise<import("../types").IWebResponseCompatible<{
+    broken: boolean;
+    commit_hash: string | null;
+    created_at: string;
+    description: string;
+    hyperlink: string | null;
+    id: number;
+    min: boolean;
+    path_build_artifact: string | null;
+    pre: boolean;
+    stable: boolean;
+    system: string;
+    title: string | null;
+    updated_at: string | null;
+    version: string;
+}[]>>;
+export declare function server_get_versions_software_with_build_urls(): Promise<import("../types").IWebResponseCompatible<import("../types").IVersionsSoftwareWithBuildUrl[]>>;
+export declare function server_get_versions_software_by_system_with_build_urls(system: string): Promise<import("../types").IWebResponseCompatible<import("../types").IVersionsSoftwareWithBuildUrl[]>>;
+export declare function server_create_version_software(newVersionSoftware: VersionsSoftwareInsert): Promise<import("../types").IWebResponseCompatible<{
+    broken: boolean;
+    commit_hash: string | null;
+    created_at: string;
+    description: string;
+    hyperlink: string | null;
+    id: number;
+    min: boolean;
+    path_build_artifact: string | null;
+    pre: boolean;
+    stable: boolean;
+    system: string;
+    title: string | null;
+    updated_at: string | null;
+    version: string;
+} | null>>;
+export declare function server_update_version_software(version_id: number, updatedVersionSoftware: Partial<VersionsSoftwareInsert>): Promise<import("../types").IWebResponseCompatible<{
+    broken: boolean;
+    commit_hash: string | null;
+    created_at: string;
+    description: string;
+    hyperlink: string | null;
+    id: number;
+    min: boolean;
+    path_build_artifact: string | null;
+    pre: boolean;
+    stable: boolean;
+    system: string;
+    title: string | null;
+    updated_at: string | null;
+    version: string;
+} | null>>;
+export declare function server_delete_version_software(version_id: number): Promise<import("../types").IWebResponseCompatible<{
+    broken: boolean;
+    commit_hash: string | null;
+    created_at: string;
+    description: string;
+    hyperlink: string | null;
+    id: number;
+    min: boolean;
+    path_build_artifact: string | null;
+    pre: boolean;
+    stable: boolean;
+    system: string;
+    title: string | null;
+    updated_at: string | null;
+    version: string;
+} | null>>;

package/dist/helpers/versions_software_server.js

@@ -1,57 +1,30 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { IWebResponse } from "../types/requests";
-import { generateSignedUrlsBatchWithClient } from "./storage_internal";
-async function attachBuildArtifactUrls(client, data) {
-    const uniquePaths = Array.from(new Set(data
-        .map((version) => version.path_build_artifact)
-        .filter((path) => !!path)));
-    if (uniquePaths.length === 0) {
-        return data.map((version) => ({
-            ...version,
-            build_artifact_url: null,
-        }));
-    }
-    const signedUrls = await generateSignedUrlsBatchWithClient(client, uniquePaths);
-    const urlMap = new Map();
-    uniquePaths.forEach((path, index) => {
-        urlMap.set(path, signedUrls[index]);
-    });
-    return data.map((version) => ({
-        ...version,
-        build_artifact_url: version.path_build_artifact
-            ? urlMap.get(version.path_build_artifact) ?? null
-            : null,
-    }));
-}
+import { create_version_software, delete_version_software, get_versions_software, get_versions_software_by_system, get_versions_software_by_system_with_build_urls, get_versions_software_with_build_urls, update_version_software, } from "./versions_software";
 export async function server_get_versions_software() {
     const client = await newServerClient();
-    const { data, error } = await client
-        .from("versions_software")
-        .select("*")
-        .order("created_at", { ascending: false });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    if (!data) {
-        return IWebResponse.error("No software versions found").to_compatible();
-    }
-    const withUrls = await attachBuildArtifactUrls(client, data);
-    return IWebResponse.success(withUrls).to_compatible();
+    return get_versions_software(client);
 }
 export async function server_get_versions_software_by_system(system) {
     const client = await newServerClient();
-    const { data, error } = await client
-        .from("versions_software")
-        .select("*")
-        .eq("system", system)
-        .order("created_at", { ascending: false });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    if (!data) {
-        return IWebResponse.error(`No software versions found for system: ${system}`).to_compatible();
-    }
-    const withUrls = await attachBuildArtifactUrls(client, data);
-    return IWebResponse.success(withUrls).to_compatible();
+    return get_versions_software_by_system(client, system);
+}
+export async function server_get_versions_software_with_build_urls() {
+    const client = await newServerClient();
+    return get_versions_software_with_build_urls(client);
+}
+export async function server_get_versions_software_by_system_with_build_urls(system) {
+    const client = await newServerClient();
+    return get_versions_software_by_system_with_build_urls(client, system);
+}
+export async function server_create_version_software(newVersionSoftware) {
+    const client = await newServerClient();
+    return create_version_software(client, newVersionSoftware);
+}
+export async function server_update_version_software(version_id, updatedVersionSoftware) {
+    const client = await newServerClient();
+    return update_version_software(client, version_id, updatedVersionSoftware);
+}
+export async function server_delete_version_software(version_id) {
+    const client = await newServerClient();
+    return delete_version_software(client, version_id);
 }

package/dist/helpers/zones.d.ts

@@ -1,19 +1,4 @@
 import { IZoneWithActions } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
-import { SupabaseClient } from "@supabase/supabase-js";
-/**
- * Get more zones and actions for a herd
- * @param herd_id - The ID of the herd to get zones and actions for
- * @param offset - The offset to start the query from
- * @param page_count - The number of zones and actions to return
- * @returns A list of zones and actions
- * @throws An error if the zones or actions are not fetched
- */
-export declare function server_get_more_zones_and_actions_for_herd(herd_id: number, offset: number, page_count?: number, client?: SupabaseClient): Promise<IWebResponseCompatible<IZoneWithActions[]>>;
-/**
- * Create zones and actions for a herd
- * @param zones - The zones to create
- * @returns A list of zones and actions
- * @throws An error if the zones or actions are not created
- */
+export declare function server_get_more_zones_and_actions_for_herd(herd_id: number, offset: number, page_count?: number): Promise<IWebResponseCompatible<IZoneWithActions[]>>;
 export declare function server_create_zones_with_actions(zones: IZoneWithActions[]): Promise<IWebResponseCompatible<IZoneWithActions[]>>;

package/dist/helpers/zones.js

@@ -1,108 +1,8 @@
 import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
-/**
- * Get more zones and actions for a herd
- * @param herd_id - The ID of the herd to get zones and actions for
- * @param offset - The offset to start the query from
- * @param page_count - The number of zones and actions to return
- * @returns A list of zones and actions
- * @throws An error if the zones or actions are not fetched
- */
-export async function server_get_more_zones_and_actions_for_herd(herd_id, offset, page_count = 10, client) {
-    const from = offset * page_count;
-    const to = from + page_count - 1;
-    const supabase = client || (await newServerClient());
-    // make rpc call to get_events_with_tags_for_herd(herd_id, offset, limit)
-    const { data, error } = await supabase.rpc("get_zones_and_actions_for_herd", {
-        herd_id_caller: herd_id,
-        offset_caller: from,
-        limit_caller: page_count,
-    });
-    if (error) {
-        console.warn("Error fetching zones and actions for herd:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    return IWebResponse.success(data.map((zone) => ({
-        ...zone,
-        actions: zone.actions ?? [],
-    }))).to_compatible();
+import { create_zones_with_actions_query, get_more_zones_and_actions_for_herd_query, } from "./zones.queries";
+export async function server_get_more_zones_and_actions_for_herd(herd_id, offset, page_count = 10) {
+    return get_more_zones_and_actions_for_herd_query(await newServerClient(), herd_id, offset, page_count);
 }
-/**
- * Create zones and actions for a herd
- * @param zones - The zones to create
- * @returns A list of zones and actions
- * @throws An error if the zones or actions are not created
- */
 export async function server_create_zones_with_actions(zones) {
-    // loop through plans and format
-    let actions = zones.flatMap((zone) => zone.actions);
-    let formatted_zones = zones.map((zone) => {
-        let formatted_zone = { ...zone };
-        delete formatted_zone.id;
-        delete formatted_zone.inserted_at;
-        delete formatted_zone.actions;
-        return formatted_zone;
-    });
-    let formatted_actions = actions.map((action) => {
-        let formatted_action = { ...action };
-        delete formatted_action.id;
-        delete formatted_action.zone_id;
-        delete formatted_action.inserted_at;
-        return formatted_action;
-    });
-    const supabase = await newServerClient();
-    // insert data and return the response
-    const { data, error } = await supabase
-        .from("zones")
-        .insert(formatted_zones)
-        .select("*");
-    if (error) {
-        let msg = `Error creating zones: ${error.message}`;
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: msg,
-            data: null,
-        };
-    }
-    // get zone id
-    let zone_ids = data.map((zone) => {
-        return zone.id;
-    });
-    // if zone ids length is zero, return error
-    if (zone_ids.length === 0) {
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: "No zones created",
-            data: null,
-        };
-    }
-    // add zone id to formatted actions
-    formatted_actions.forEach((action) => {
-        action.zone_id = zone_ids[0];
-    });
-    // insert actions
-    const { data: data_actions, error: error_actions } = await supabase
-        .from("actions")
-        .insert(formatted_actions)
-        .select("*");
-    if (error_actions) {
-        let msg = `Error creating actions: ${error_actions.message}`;
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: msg,
-            data: null,
-        };
-    }
-    // merge data and data_actions
-    const merged_data = data.map((zone) => {
-        return {
-            ...zone,
-            actions: data_actions.filter((action) => action.zone_id === zone.id),
-        };
-    });
-    return IWebResponse.success(merged_data).to_compatible();
+    return create_zones_with_actions_query(await newServerClient(), zones);
 }

package/dist/helpers/zones.queries.d.ts

@@ -0,0 +1,6 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IZoneWithActions } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { Database } from "../types/supabase";
+export declare function get_more_zones_and_actions_for_herd_query(client: SupabaseClient<Database>, herd_id: number, offset: number, page_count?: number): Promise<IWebResponseCompatible<IZoneWithActions[]>>;
+export declare function create_zones_with_actions_query(client: SupabaseClient<Database>, zones: IZoneWithActions[]): Promise<IWebResponseCompatible<IZoneWithActions[]>>;

package/dist/helpers/zones.queries.js

@@ -0,0 +1,78 @@
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function get_more_zones_and_actions_for_herd_query(client, herd_id, offset, page_count = 10) {
+    const from = offset * page_count;
+    const { data, error } = await client.rpc("get_zones_and_actions_for_herd", {
+        herd_id_caller: herd_id,
+        offset_caller: from,
+        limit_caller: page_count,
+    });
+    if (error) {
+        console.warn("Error fetching zones and actions for herd:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success((data ?? []).map((zone) => ({
+        ...zone,
+        actions: zone.actions ?? [],
+    }))).to_compatible();
+}
+export async function create_zones_with_actions_query(client, zones) {
+    const actions = zones.flatMap((zone) => zone.actions);
+    const formatted_zones = zones.map((zone) => {
+        const formatted_zone = { ...zone };
+        delete formatted_zone.id;
+        delete formatted_zone.inserted_at;
+        delete formatted_zone.actions;
+        return formatted_zone;
+    });
+    const formatted_actions = actions.map((action) => {
+        const formatted_action = { ...action };
+        delete formatted_action.id;
+        delete formatted_action.zone_id;
+        delete formatted_action.inserted_at;
+        return formatted_action;
+    });
+    const { data, error } = await client
+        .from("zones")
+        .insert(formatted_zones)
+        .select("*");
+    if (error) {
+        const msg = `Error creating zones: ${error.message}`;
+        return {
+            status: EnumWebResponse.ERROR,
+            msg,
+            data: null,
+        };
+    }
+    const zone_ids = data.map((zone) => zone.id);
+    if (zone_ids.length === 0) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: "No zones created",
+            data: null,
+        };
+    }
+    formatted_actions.forEach((action) => {
+        action.zone_id = zone_ids[0];
+    });
+    const { data: data_actions, error: error_actions } = await client
+        .from("actions")
+        .insert(formatted_actions)
+        .select("*");
+    if (error_actions) {
+        const msg = `Error creating actions: ${error_actions.message}`;
+        return {
+            status: EnumWebResponse.ERROR,
+            msg,
+            data: null,
+        };
+    }
+    const merged_data = data.map((zone) => ({
+        ...zone,
+        actions: data_actions.filter((action) => action.zone_id === zone.id),
+    }));
+    return IWebResponse.success(merged_data).to_compatible();
+}

package/dist/hooks/useAuthorizedRealtimeTopics.js

@@ -1,14 +1,20 @@
 "use client";
-import { useMemo } from "react";
+import { useMemo, useRef } from "react";
 import { filter_realtime_topics } from "../helpers/realtime_topic_access";
 import { useOptionalClientAbilitiesMint } from "../providers/ScoutRefreshProvider";
 export function useAuthorizedRealtimeTopics(topics) {
     const abilities = useOptionalClientAbilitiesMint();
     const topicsKey = topics.join("|");
-    return useMemo(() => {
+    const filteredTopics = useMemo(() => {
         const requested = topicsKey.split("|").filter(Boolean);
         if (!abilities)
             return requested;
         return filter_realtime_topics(abilities.status, abilities.mint, requested);
     }, [abilities, topicsKey]);
+    const filteredKey = filteredTopics.join("|");
+    const stableTopicsRef = useRef({ key: filteredKey, topics: filteredTopics });
+    if (stableTopicsRef.current.key !== filteredKey) {
+        stableTopicsRef.current = { key: filteredKey, topics: filteredTopics };
+    }
+    return stableTopicsRef.current.topics;
 }

package/dist/hooks/useInfiniteQuery.js

@@ -1,3 +1,4 @@
+"use client";
 import { useState, useCallback, useMemo, useEffect, useRef } from "react";
 import { useGetSessionsInfiniteByHerdQuery, useGetSessionsInfiniteByDeviceQuery, useGetEventsInfiniteByHerdQuery, useGetEventsInfiniteByDeviceQuery, useGetArtifactsInfiniteByHerdQuery, useGetArtifactsInfiniteByDeviceQuery, useGetFeedInfiniteByHerdQuery, useGetFeedInfiniteByDeviceQuery, useGetAnalysisJobsInfiniteQuery, useGetAnalysisTasksInfiniteQuery, } from "../store/api";
 function useInfiniteFiltersKey(options) {
@@ -773,10 +774,13 @@ export const useInfiniteFeedByDevice = (deviceId, options) => {
             }
             return prev;
         });
-        if (hasMore && nextCursor != null) {
-            setCurrentCursor(nextCursor);
-        }
-    }, [currentQuery.data, currentQuery.isLoading, cursorForQuery, pages.length, options.limit]);
+    }, [
+        currentQuery.data,
+        currentQuery.isLoading,
+        cursorForQuery,
+        pages.length,
+        options.limit,
+    ]);
     const loadMore = useCallback(() => {
         if (lastResult?.hasMore &&
             lastResult.nextCursor != null &&
@@ -952,26 +956,26 @@ export const useInfiniteAnalysisTasks = (options) => {
         error: currentQuery.error,
     };
 };
-// =====================================================
-// INTERSECTION OBSERVER HOOK FOR AUTO-LOADING
-// =====================================================
 export const useIntersectionObserver = (callback, options = {}) => {
     const [element, setElement] = useState(null);
+    const root = options.root ?? null;
+    const rootMargin = options.rootMargin ?? "0px";
+    const thresholdKey = (Array.isArray(options.threshold)
+        ? options.threshold
+        : [options.threshold ?? 0.1]).join(",");
     useEffect(() => {
         if (!element)
             return;
+        const thresholds = thresholdKey.split(",").map(Number);
+        const threshold = thresholds.length === 1 ? thresholds[0] : thresholds;
         const observer = new IntersectionObserver((entries) => {
             const first = entries[0];
             if (first.isIntersecting) {
                 callback();
             }
-        }, { threshold: 0.1, ...options });
+        }, { root, rootMargin, threshold });
         observer.observe(element);
-        return () => {
-            if (element) {
-                observer.unobserve(element);
-            }
-        };
-    }, [element, callback, options]);
+        return () => observer.disconnect();
+    }, [element, callback, root, rootMargin, thresholdKey]);
     return setElement;
 };