@ludo.ninja/components 2.3.6 → 2.3.8

package/build/api/server-search/queries/useFindCreations/index.d.ts

@@ -0,0 +1,34 @@
+import { TCreation } from '../../../../entities/creation/types';
+import { ApolloClient, NormalizedCacheObject } from "@apollo/client";
+import { searchSchema as schema } from "@ludo.ninja/api";
+export declare const prefetchFindCreations: ({ term, input, page }: schema.IQueryFindCreationsArgs, apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        findCreations: null;
+    };
+}>;
+export declare const useFindCreations: ({ term, input, page }: schema.IQueryFindCreationsArgs) => {
+    loadMore: (pageToken: string | null) => Promise<void>;
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    results: number;
+    creations: TCreation[];
+    nextPageToken: string | null;
+    refetchQuery: () => Promise<void>;
+};
+declare const _default: {
+    useFindCreations: ({ term, input, page }: schema.IQueryFindCreationsArgs) => {
+        loadMore: (pageToken: string | null) => Promise<void>;
+        loading: boolean;
+        error: import("@apollo/client").ApolloError | undefined;
+        results: number;
+        creations: TCreation[];
+        nextPageToken: string | null;
+        refetchQuery: () => Promise<void>;
+    };
+    prefetchFindCreations: ({ term, input, page }: schema.IQueryFindCreationsArgs, apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+        data: {
+            findCreations: null;
+        };
+    }>;
+};
+export default _default;

package/build/api/server-search/queries/useFindCreations/index.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFindCreations = exports.prefetchFindCreations = void 0;
+const builder_1 = require("../../../../entities/creation/builder");
+const ui_1 = require("../../../../store/ui");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const type_1 = require("@ludo.ninja/ui/build/system/Alert/type");
+const react_1 = require("react");
+const prefetchFindCreations = ({ term, input, page }, apolloClient) => {
+    return apolloClient
+        .query({
+        query: api_1.searchSchema.FindCreationsDocument,
+        variables: {
+            term,
+            input,
+            page,
+        },
+        context: { uri: api_1.hosts.serverSearchHost },
+        fetchPolicy: "network-only",
+    })
+        .catch(() => {
+        return {
+            data: { findCreations: null },
+        };
+    });
+};
+exports.prefetchFindCreations = prefetchFindCreations;
+const maxCreationLength = 1000;
+const useFindCreations = ({ term, input, page }) => {
+    const [creations, setCreations] = (0, react_1.useState)([]);
+    const [nextPageToken, setNextPageToken] = (0, react_1.useState)(null);
+    const [results, setResults] = (0, react_1.useState)(0);
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const { error, loading, fetchMore, networkStatus, refetch } = api_1.searchSchema.useFindCreationsQuery({
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        variables: {
+            term,
+            input,
+            page,
+        },
+        onCompleted: ({ findCreations: { creations, ...nextPage } }) => {
+            setCreations(creations.map((creation) => (0, builder_1.buildCreation)(creation)));
+            setResults(nextPage.nextPage?.elements || 0);
+            setNextPageToken(nextPage.nextPage?.token || null);
+        },
+        onError: () => {
+            openAlert({
+                type: type_1.alertVariants.error,
+                caption: "Oops, something went wrong.",
+            });
+            setCreations([]);
+            setNextPageToken(null);
+        },
+    });
+    const loadingMoreCreations = networkStatus === client_1.NetworkStatus.fetchMore;
+    return {
+        loadMore,
+        loading: loading || loadingMoreCreations,
+        error,
+        results,
+        creations,
+        nextPageToken,
+        refetchQuery,
+    };
+    async function refetchQuery() {
+        await refetch();
+    }
+    async function loadMore(pageToken) {
+        if (!pageToken || creations.length >= maxCreationLength)
+            return;
+        await fetchMore({
+            variables: {
+                page: {
+                    token: pageToken,
+                    ...(page && "size" in page ? { size: page.size } : {}),
+                },
+            },
+            updateQuery: (prev, { fetchMoreResult }) => {
+                if (!fetchMoreResult)
+                    return prev;
+                const { creations: nextCreations, ...page } = fetchMoreResult.findCreations;
+                if (prev !== null && prev.hasOwnProperty("findCreations")) {
+                    const { creations: prevCreations } = prev.findCreations;
+                    return {
+                        findCreations: {
+                            creations: [...prevCreations, ...nextCreations],
+                            ...page,
+                        },
+                    };
+                }
+                else {
+                    return {
+                        findCreations: { creations: nextCreations, ...page },
+                    };
+                }
+            },
+        });
+    }
+};
+exports.useFindCreations = useFindCreations;
+exports.default = { useFindCreations: exports.useFindCreations, prefetchFindCreations: exports.prefetchFindCreations };

package/build/api/server-search/queries/useFindProfilesByName/index.d.ts

@@ -0,0 +1,32 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import { searchSchema } from '@ludo.ninja/api';
+import { ProfileEntity } from '@ludo.ninja/core';
+export declare const prefetchFindProfilesByName: ({ name, page }: searchSchema.IQueryFindProfilesByNameArgs, apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        findProfilesByName: null;
+    };
+}>;
+export declare const useFindProfilesByName: ({ name, page, }: searchSchema.IQueryFindProfilesByNameArgs) => {
+    data: searchSchema.IFindProfilesByNameQuery | undefined;
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    clientProfiles: ProfileEntity[] | null;
+    clientNextPageToken: string | null;
+    clientResults: number;
+};
+declare const _default: {
+    prefetchFindProfilesByName: ({ name, page }: searchSchema.IQueryFindProfilesByNameArgs, apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+        data: {
+            findProfilesByName: null;
+        };
+    }>;
+    useFindProfilesByName: ({ name, page, }: searchSchema.IQueryFindProfilesByNameArgs) => {
+        data: searchSchema.IFindProfilesByNameQuery | undefined;
+        loading: boolean;
+        error: import("@apollo/client").ApolloError | undefined;
+        clientProfiles: ProfileEntity[] | null;
+        clientNextPageToken: string | null;
+        clientResults: number;
+    };
+};
+export default _default;

package/build/api/server-search/queries/useFindProfilesByName/index.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFindProfilesByName = exports.prefetchFindProfilesByName = void 0;
+const react_1 = require("react");
+const api_1 = require("@ludo.ninja/api");
+const core_1 = require("@ludo.ninja/core");
+const prefetchFindProfilesByName = ({ name, page }, apolloClient) => {
+    return apolloClient
+        .query({
+        query: api_1.searchSchema.FindProfilesByNameDocument,
+        variables: {
+            name,
+            page,
+        },
+        context: { uri: api_1.hosts.serverSearchHost },
+        fetchPolicy: 'network-only',
+    })
+        .catch(() => {
+        return {
+            data: { findProfilesByName: null },
+        };
+    });
+};
+exports.prefetchFindProfilesByName = prefetchFindProfilesByName;
+const useFindProfilesByName = ({ name, page, }) => {
+    const [profiles, setProfiles] = (0, react_1.useState)(null);
+    const [nextPageToken, setNextPageToken] = (0, react_1.useState)(null);
+    const [results, setResults] = (0, react_1.useState)(0);
+    const { data, error, loading } = api_1.searchSchema.useFindProfilesByNameQuery({
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        variables: {
+            name,
+            page,
+        },
+        fetchPolicy: 'cache-first',
+        onCompleted: ({ findProfilesByName }) => {
+            setProfiles(findProfilesByName.profiles.map((profile) => new core_1.ProfileEntity(profile)));
+            setNextPageToken(findProfilesByName.nextPage?.token || null);
+            setResults(findProfilesByName.nextPage?.elements || 0);
+        },
+        onError: () => {
+            setProfiles([]);
+            setNextPageToken(null);
+            setResults(0);
+        },
+    });
+    return {
+        data,
+        loading,
+        error,
+        clientProfiles: profiles,
+        clientNextPageToken: nextPageToken,
+        clientResults: results,
+    };
+};
+exports.useFindProfilesByName = useFindProfilesByName;
+exports.default = { prefetchFindProfilesByName: exports.prefetchFindProfilesByName, useFindProfilesByName: exports.useFindProfilesByName };

package/build/api/server-search/queries/useFindShowcaseItems/index.d.ts

@@ -0,0 +1,2 @@
+declare const useFindShowCaseItems: () => void;
+export default useFindShowCaseItems;

package/build/api/server-search/queries/useFindShowcaseItems/index.js

@@ -0,0 +1,42 @@
+"use strict";
+// import { useState } from 'react';
+//
+// import { useLazyQuery } from '@apollo/client';
+//
+// import { hosts, searchSchema as schema } from '@ludo.ninja/api';
+Object.defineProperty(exports, "__esModule", { value: true });
+const useFindShowCaseItems = () => {
+    // const [showcaseItemPage, setShowcaseItemPage] =
+    //   useState<schema.IShowcaseItemPage | null>(null);
+    //
+    // const [findShowcaseItems, { error, loading }] = useLazyQuery(
+    //   schema.FindShowcaseItemsDocument,
+    //   {
+    //     context: {
+    //       uri: hosts.searchHost,
+    //     },
+    //     pollInterval: 0,
+    //     notifyOnNetworkStatusChange: true,
+    //     fetchPolicy: 'cache-and-network',
+    //     onCompleted: ({ findShowcaseItems }) => {
+    //       setShowcaseItemPage(findShowcaseItems);
+    //     },
+    //     onError: () => {
+    //       setShowcaseItemPage(null);
+    //     },
+    //   }
+    // );
+    //
+    // return { load, loading, error, showcaseItemPage };
+    // function load(
+    //   term: string,
+    //   input: schema.IShowcaseItemFilterInput,
+    //   pageSize: string,
+    //   pageToken: string
+    // ) {
+    //   findShowcaseItems({
+    //     variables: { term, input, pageSize, pageToken },
+    //   });
+    // }
+};
+exports.default = useFindShowCaseItems;

package/build/api/server-search/queries/useFindUserCreations/index.d.ts

@@ -0,0 +1,16 @@
+import { TCreation } from '../../../../entities/creation/types';
+import { searchSchema as schema } from "@ludo.ninja/api";
+declare const useFindUserCreations: ({ ownerId, input, scrollTab, }: {
+    scrollTab: string | undefined;
+    ownerId: schema.IQueryFindUserCreationsArgs["ownerId"];
+    input: schema.IQueryFindUserCreationsArgs["input"];
+}) => {
+    isLoading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    totalResults: number;
+    creations: TCreation[];
+    refetchQuery: () => Promise<void>;
+    loadMore: () => Promise<void>;
+    isNextLoading: boolean;
+};
+export default useFindUserCreations;

package/build/api/server-search/queries/useFindUserCreations/index.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const builder_1 = require("../../../../entities/creation/builder");
+const getPageSizeAssets_1 = require("../../../../utils/getPageSizeAssets");
+const api_1 = require("@ludo.ninja/api");
+const react_1 = require("react");
+const limit = 20;
+const useFindUserCreations = ({ ownerId, input, scrollTab, }) => {
+    const [creations, setCreations] = (0, react_1.useState)([]);
+    const nextPageToken = (0, react_1.useRef)(null);
+    const [results, setResults] = (0, react_1.useState)(0);
+    const [isLoading, setIsLoading] = (0, react_1.useState)(true);
+    const [isNextLoading, setIsNextLoading] = (0, react_1.useState)(false);
+    const isHaveNextPage = creations.length < results;
+    const [fetchCreations, { error, refetch, fetchMore }] = api_1.searchSchema.useFindUserCreationsLazyQuery({
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        fetchPolicy: "no-cache",
+        onCompleted: ({ findUserCreations: { creations, ...nextPage } }) => {
+            setCreations(creations.map((creation) => (0, builder_1.buildCreation)(creation)));
+            setResults(nextPage.nextPage?.elements || 0);
+            setIsLoading(false);
+            nextPageToken.current = nextPage.nextPage?.token || null;
+        },
+        onError: () => {
+            setCreations([]);
+            setIsLoading(false);
+            nextPageToken.current = null;
+        },
+    });
+    (0, react_1.useEffect)(() => {
+        setIsLoading(true);
+        fetchCreations({
+            variables: {
+                ownerId,
+                input,
+                page: {
+                    size: (0, getPageSizeAssets_1.getPageSize)({
+                        scrollTab,
+                        limit,
+                    }),
+                    token: "",
+                },
+            },
+        });
+    }, [input, ownerId]);
+    async function refetchQuery() {
+        await refetch();
+    }
+    async function loadMore() {
+        if (!nextPageToken.current || !isHaveNextPage)
+            return;
+        setIsNextLoading(true);
+        try {
+            const { data } = await fetchMore({
+                variables: {
+                    ownerId,
+                    input,
+                    page: {
+                        token: nextPageToken.current,
+                        size: limit,
+                    },
+                },
+                updateQuery: (previousQueryResult) => {
+                    return previousQueryResult;
+                },
+            });
+            const { creations: nextCreations, ...nextPage } = data.findUserCreations;
+            setCreations((prevCreations) => [
+                ...prevCreations,
+                ...nextCreations.map((creation) => (0, builder_1.buildCreation)(creation)),
+            ]);
+            setResults(nextPage.nextPage?.elements || 0);
+            nextPageToken.current = nextPage.nextPage?.token || null;
+        }
+        catch (error) {
+            //todo uncomment next line
+            // throw new Error(error as string);
+        }
+        finally {
+            setIsNextLoading(false);
+        }
+    }
+    return {
+        isLoading,
+        error,
+        totalResults: results,
+        creations,
+        refetchQuery,
+        loadMore,
+        isNextLoading,
+    };
+};
+exports.default = useFindUserCreations;

package/build/api/server-search/queries/useFindUserLudoCreations/index.d.ts

@@ -0,0 +1,15 @@
+import { TCreation } from '../../../../entities/creation/types';
+import { searchSchema as schema } from "@ludo.ninja/api";
+declare const useFindUserLudoCreations: ({ ownerId, scrollTab, }: {
+    scrollTab: string | undefined;
+    ownerId: schema.IQueryFindUserLudoCreationsArgs["ownerId"];
+}) => {
+    isLoading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    totalResults: number;
+    creations: TCreation[];
+    refetchQuery: () => Promise<void>;
+    loadMore: () => Promise<void>;
+    isNextLoading: boolean;
+};
+export default useFindUserLudoCreations;

package/build/api/server-search/queries/useFindUserLudoCreations/index.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const builder_1 = require("../../../../entities/creation/builder");
+const getPageSizeAssets_1 = require("../../../../utils/getPageSizeAssets");
+const api_1 = require("@ludo.ninja/api");
+const react_1 = require("react");
+const limit = 20;
+const useFindUserLudoCreations = ({ ownerId, scrollTab, }) => {
+    const [creations, setCreations] = (0, react_1.useState)([]);
+    const nextPageToken = (0, react_1.useRef)(null);
+    const [results, setResults] = (0, react_1.useState)(0);
+    const [isLoading, setIsLoading] = (0, react_1.useState)(true);
+    const [isNextLoading, setIsNextLoading] = (0, react_1.useState)(false);
+    const isHaveNextPage = creations.length < results;
+    const [fetchLudoCreations, { error, refetch, fetchMore }] = api_1.searchSchema.useFindUserLudoCreationsLazyQuery({
+        context: {
+            uri: api_1.hosts.searchHost,
+        },
+        fetchPolicy: "no-cache",
+        onCompleted: ({ findUserLudoCreations: { creations, ...nextPage } }) => {
+            setCreations(creations.map((creation) => (0, builder_1.buildCreation)(creation)));
+            setResults(nextPage.nextPage?.elements || 0);
+            setIsLoading(false);
+            nextPageToken.current = nextPage.nextPage?.token || null;
+        },
+        onError: () => {
+            setCreations([]);
+            setIsLoading(false);
+            nextPageToken.current = null;
+        },
+    });
+    (0, react_1.useEffect)(() => {
+        setIsLoading(true);
+        fetchLudoCreations({
+            variables: {
+                ownerId,
+                page: {
+                    size: (0, getPageSizeAssets_1.getPageSize)({
+                        scrollTab,
+                        limit,
+                    }),
+                    token: "",
+                },
+            },
+        });
+    }, [ownerId]);
+    async function refetchQuery() {
+        await refetch();
+    }
+    async function loadMore() {
+        if (!nextPageToken.current || !isHaveNextPage)
+            return;
+        setIsNextLoading(true);
+        try {
+            const { data } = await fetchMore({
+                variables: {
+                    ownerId,
+                    page: {
+                        token: nextPageToken.current,
+                        size: limit,
+                    },
+                },
+                updateQuery: (previousQueryResult) => {
+                    return previousQueryResult;
+                },
+            });
+            const { creations: nextCreations, ...nextPage } = data.findUserLudoCreations;
+            setCreations((prevCreations) => [
+                ...prevCreations,
+                ...nextCreations.map((creation) => (0, builder_1.buildCreation)(creation)),
+            ]);
+            setResults(nextPage.nextPage?.elements || 0);
+            nextPageToken.current = nextPage.nextPage?.token || null;
+        }
+        catch (error) {
+            //todo uncomment next line
+            // throw new Error(error as string);
+        }
+        finally {
+            setIsNextLoading(false);
+        }
+    }
+    return {
+        isLoading,
+        error,
+        totalResults: results,
+        creations,
+        refetchQuery,
+        loadMore,
+        isNextLoading,
+    };
+};
+exports.default = useFindUserLudoCreations;

package/build/api/server-search/queries/useFindUserShowcaseItems/index.d.ts

@@ -0,0 +1,2 @@
+declare const useFindUserShowcaseItems: () => void;
+export default useFindUserShowcaseItems;

package/build/api/server-search/queries/useFindUserShowcaseItems/index.js

@@ -0,0 +1,40 @@
+"use strict";
+// import { useState } from 'react';
+//
+// import { useLazyQuery } from '@apollo/client';
+//
+// import { hosts, searchSchema as schema } from '@ludo.ninja/api';
+Object.defineProperty(exports, "__esModule", { value: true });
+const useFindUserShowcaseItems = () => {
+    // const [showcaseItemPage, setShowcaseItemPage] =
+    //   useState<schema.IShowcaseItemPage | null>(null);
+    //
+    // const [findUserShowcaseItems, { data, error, loading }] = useLazyQuery(
+    //   schema.FindUserShowcaseItemsDocument,
+    //   {
+    //     context: {
+    //       uri: hosts.searchHost,
+    //     },
+    //     onCompleted: ({ findUserShowcaseItems }) => {
+    //       setShowcaseItemPage(findUserShowcaseItems);
+    //     },
+    //     onError: () => setShowcaseItemPage(null),
+    //     notifyOnNetworkStatusChange: true,
+    //     fetchPolicy: 'cache-and-network',
+    //   }
+    // );
+    //
+    // return { loading, error, data, load, showcaseItemPage };
+    //
+    // function load(
+    //   ownerId: string,
+    //   input: schema.IShowcaseItemFilterInput,
+    //   pageSize: string,
+    //   pageToken: string
+    // ) {
+    //   findUserShowcaseItems({
+    //     variables: { ownerId, input, pageSize, pageToken },
+    //   });
+    // }
+};
+exports.default = useFindUserShowcaseItems;

package/build/api/subscriptions/SubscriberInviteNotification.d.ts

@@ -0,0 +1 @@
+export declare const SubscriberInviteNotification: () => import("react/jsx-runtime").JSX.Element | null;

package/build/api/subscriptions/SubscriberInviteNotification.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriberInviteNotification = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const router_1 = require("next/router");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const store_1 = require("../../modules/user/store");
+const ui_1 = require("../../store/ui");
+const notifications_1 = require("../../modules/notifications");
+const ludoDomains_1 = require("@ludo.ninja/core/build/ludoDomains");
+const env_1 = require("../../store/env");
+const Subscription = () => {
+    const NEXT_PUBLIC_ENV_VALUE = (0, env_1.useEnvStore)(state => state.NEXT_PUBLIC_ENV_VALUE);
+    const { authToken } = api_1.authCookies.getCookies();
+    const router = (0, router_1.useRouter)();
+    const addNotification = (0, ui_1.useUiStore)((state) => state.addNotification);
+    (0, client_1.useSubscription)(api_1.experiencesSchema.OnInviteCodeUsedDocument, {
+        variables: { authToken },
+        // onComplete: () => {
+        //   console.log('complete');
+        // },
+        onData: (options) => {
+            const inviteCode = options.data.data?.onInviteCodeUsed.inviteCode;
+            // console.log('onData', inviteCode);
+            if (inviteCode) {
+                addNotification((0, notifications_1.createInviteNotification)({
+                    inviteCode,
+                    onClick: () => {
+                        const domain = ludoDomains_1.ludoDomains[NEXT_PUBLIC_ENV_VALUE]["app"];
+                        if (domain === window.origin) {
+                            router.push(`/invite-codes`);
+                        }
+                        else {
+                            window.open(`${domain}/invite-codes`, '_self');
+                        }
+                    },
+                }));
+            }
+        },
+    });
+    return null;
+};
+const SubscriberInviteNotification = () => {
+    const isSignedIn = (0, store_1.useUserStore)((state) => state.isSignedIn);
+    const [startSubscription, setStartSubscription] = (0, react_1.useState)(false);
+    (0, react_1.useEffect)(() => {
+        setStartSubscription(isSignedIn);
+    }, [isSignedIn]);
+    return startSubscription ? (0, jsx_runtime_1.jsx)(Subscription, {}) : null;
+};
+exports.SubscriberInviteNotification = SubscriberInviteNotification;

package/build/api/subscriptions/SubscriberNotifications.d.ts

@@ -0,0 +1 @@
+export declare const SubscriberNotification: () => import("react/jsx-runtime").JSX.Element;

package/build/api/subscriptions/SubscriberNotifications.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriberNotification = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const store_1 = require("../../modules/user/store");
+const NoSSR_1 = __importDefault(require("../../components/base/NoSSR"));
+const router_1 = require("next/router");
+const react_1 = require("react");
+const SubscriptionNotificationSPA_1 = require("./SubscriptionNotificationSPA");
+const SubscriberNotification = () => {
+    const isSignedIn = (0, store_1.useUserStore)((state) => state.isSignedIn);
+    const key = isSignedIn ? "all includes" : "only common";
+    const router = (0, router_1.useRouter)();
+    const [isWindowVisible, setIsWindowVisible] = (0, react_1.useState)(true);
+    (0, react_1.useEffect)(() => {
+        const changeVisibility = () => {
+            setIsWindowVisible(!document.hidden);
+        };
+        document.addEventListener("visibilitychange", changeVisibility);
+        return () => {
+            document.removeEventListener("visibilitychange", changeVisibility);
+        };
+    }, []);
+    return ((0, jsx_runtime_1.jsx)(NoSSR_1.default, { children: isWindowVisible && (0, jsx_runtime_1.jsx)(SubscriptionNotificationSPA_1.Subscription, { routerPush: router.push }, key) }));
+};
+exports.SubscriberNotification = SubscriberNotification;

package/build/api/subscriptions/SubscriberOpportunityNotification.d.ts

@@ -0,0 +1 @@
+export declare const SubscriberOpportunityNotification: () => import("react/jsx-runtime").JSX.Element;