@ludo.ninja/components 2.1.3 → 2.1.5

package/build/api/server-identities/mutations/useAddWalletTon/index.d.ts

@@ -0,0 +1,6 @@
+import { identitySchema as schema } from '@ludo.ninja/api';
+declare const useAddWalletTon: () => {
+    addWalletTon: ({ request }: schema.IMutationAddWalletTonArgs) => Promise<import("@apollo/client").FetchResult<any>>;
+    error: import("@apollo/client").ApolloError | undefined;
+};
+export default useAddWalletTon;

package/build/api/server-identities/mutations/useAddWalletTon/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const data_1 = require("@ludo.ninja/ui/build/system/Alert/data");
+const ui_1 = require("../../../../store/ui");
+const useAddWalletTon = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate, { error }] = (0, client_1.useMutation)(api_1.identitySchema.AddWalletTonDocument, {
+        context: {
+            uri: api_1.hosts.identityHost,
+        },
+        onCompleted: () => {
+            openAlert({
+                ...data_1.alertSuccess,
+                caption: 'TON wallet successfully added!',
+                text: '',
+            });
+        },
+        onError: (err) => {
+            openAlert({
+                ...data_1.alertError,
+                caption: err.message,
+                text: '',
+            });
+        },
+    });
+    return { addWalletTon, error };
+    function addWalletTon({ request }) {
+        return mutate({
+            variables: { request },
+        });
+    }
+};
+exports.default = useAddWalletTon;

package/build/api/server-preferences/mutations/useSaveUserExpectations/index.d.ts

@@ -0,0 +1,4 @@
+declare const useSaveUserExpectations: () => {
+    saveUserExpectations: (expectations: string[]) => Promise<void>;
+};
+export default useSaveUserExpectations;

package/build/api/server-preferences/mutations/useSaveUserExpectations/index.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("@ludo.ninja/api");
+const data_1 = require("@ludo.ninja/ui/build/system/Alert/data");
+const ui_1 = require("../../../../store/ui");
+const useSaveUserExpectations = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate] = api_1.preferencesSchema.useSaveUserExpectationsMutation({
+        context: {
+            uri: api_1.hosts.preferencesHost,
+        },
+        onCompleted: ({ saveUserExpectations }) => {
+            if (saveUserExpectations) {
+                openAlert({
+                    ...data_1.alertSuccess,
+                    caption: 'Expectations successfully added!',
+                    text: '',
+                });
+            }
+            else {
+                openAlert({
+                    ...data_1.alertError,
+                    caption: 'Sorry something went wrong :(',
+                    text: '',
+                });
+            }
+        },
+        onError: (err) => {
+            openAlert({
+                ...data_1.alertError,
+                caption: err.message,
+                text: '',
+            });
+        },
+    });
+    async function saveUserExpectations(expectations) {
+        await mutate({
+            variables: { expectations },
+        });
+    }
+    return { saveUserExpectations };
+};
+exports.default = useSaveUserExpectations;

package/build/api/server-preferences/mutations/useSaveUserInterests/index.d.ts

@@ -0,0 +1,4 @@
+declare const useSaveUserInterests: () => {
+    saveUserInterests: (interests: string[]) => Promise<void>;
+};
+export default useSaveUserInterests;

package/build/api/server-preferences/mutations/useSaveUserInterests/index.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("@ludo.ninja/api");
+const data_1 = require("@ludo.ninja/ui/build/system/Alert/data");
+const ui_1 = require("../../../../store/ui");
+const useSaveUserInterests = () => {
+    const openAlert = (0, ui_1.useUiStore)((state) => state.openAlert);
+    const [mutate] = api_1.preferencesSchema.useSaveUserInterestsMutation({
+        context: {
+            uri: api_1.hosts.preferencesHost,
+        },
+        onCompleted: ({ saveUserInterests }) => {
+            if (saveUserInterests) {
+                openAlert({
+                    ...data_1.alertSuccess,
+                    caption: 'Interests successfully added!',
+                    text: '',
+                });
+            }
+            else {
+                openAlert({
+                    ...data_1.alertError,
+                    caption: 'Sorry something went wrong :(',
+                    text: '',
+                });
+            }
+        },
+        onError: (err) => {
+            openAlert({
+                ...data_1.alertError,
+                caption: err.message,
+                text: '',
+            });
+        },
+    });
+    async function saveUserInterests(interests) {
+        await mutate({
+            variables: { interests },
+        });
+    }
+    return { saveUserInterests };
+};
+exports.default = useSaveUserInterests;

package/build/api/server-preferences/queries/useFetchExpectations/index.d.ts

@@ -0,0 +1,7 @@
+import { preferencesSchema as schema } from '@ludo.ninja/api';
+declare const useFetchExpectations: () => {
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    expectations: schema.IExpectation[] | null;
+};
+export default useFetchExpectations;

package/build/api/server-preferences/queries/useFetchExpectations/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const api_1 = require("@ludo.ninja/api");
+const useFetchExpectations = () => {
+    const [expectations, setExpectations] = (0, react_1.useState)(null);
+    const { loading, error } = api_1.preferencesSchema.useFetchExpectationsQuery({
+        context: {
+            uri: api_1.hosts.preferencesHost,
+        },
+        onCompleted: ({ fetchExpectations }) => {
+            setExpectations(fetchExpectations);
+        },
+        onError: () => {
+            setExpectations([]);
+        },
+    });
+    return { loading, error, expectations };
+};
+exports.default = useFetchExpectations;

package/build/api/server-preferences/queries/useFetchInterests/index.d.ts

@@ -0,0 +1,7 @@
+import { preferencesSchema as schema } from '@ludo.ninja/api';
+declare const useFetchInterests: () => {
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    interests: schema.IInterest[] | null;
+};
+export default useFetchInterests;

package/build/api/server-preferences/queries/useFetchInterests/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const api_1 = require("@ludo.ninja/api");
+const useFetchInterests = () => {
+    const [interests, setInterests] = (0, react_1.useState)(null);
+    const { loading, error } = api_1.preferencesSchema.useFetchInterestsQuery({
+        context: {
+            uri: api_1.hosts.preferencesHost,
+        },
+        onCompleted: ({ fetchInterests }) => {
+            setInterests(fetchInterests);
+        },
+        onError: () => {
+            setInterests(null);
+        },
+    });
+    return { loading, error, interests };
+};
+exports.default = useFetchInterests;

package/build/api/server-preferences/queries/useFetchSearchResultTimeSelection/index.d.ts

@@ -0,0 +1,12 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import { ISelectInput } from '../../../../system/Forms/Selects/MobileSelect';
+export declare const prefetchSearchResultTimeSelections: (apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        fetchSearchResultTimeSelections: null;
+    };
+}>;
+export declare const useFetchSearchResultTimeSelections: () => {
+    resultTimeSelectionsLoading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    searchResultTimeSelections: ISelectInput[] | null;
+};

package/build/api/server-preferences/queries/useFetchSearchResultTimeSelection/index.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchSearchResultTimeSelections = exports.prefetchSearchResultTimeSelections = void 0;
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const prefetchSearchResultTimeSelections = (apolloClient) => {
+    return apolloClient
+        .query({
+        query: api_1.preferencesSchema.FetchSearchResultTimeSelectionsDocument,
+        context: { uri: api_1.hosts.preferencesHost },
+        fetchPolicy: 'network-only',
+    })
+        .catch(() => {
+        return {
+            data: { fetchSearchResultTimeSelections: null },
+        };
+    });
+};
+exports.prefetchSearchResultTimeSelections = prefetchSearchResultTimeSelections;
+const useFetchSearchResultTimeSelections = () => {
+    const [searchResultTimeSelections, setSearchResultTimeSelections] = (0, react_1.useState)(null);
+    const { error, loading } = (0, client_1.useQuery)(api_1.preferencesSchema.FetchSearchResultTimeSelectionsDocument, {
+        context: {
+            uri: api_1.hosts.preferencesHost,
+        },
+        onCompleted: ({ fetchSearchResultTimeSelections }) => {
+            setSearchResultTimeSelections(fetchSearchResultTimeSelections);
+        },
+        onError: () => {
+            setSearchResultTimeSelections(null);
+        },
+    });
+    return {
+        resultTimeSelectionsLoading: loading,
+        error,
+        searchResultTimeSelections,
+    };
+};
+exports.useFetchSearchResultTimeSelections = useFetchSearchResultTimeSelections;

package/build/api/server-preferences/queries/useFetchUserInterests/index.d.ts

@@ -0,0 +1,7 @@
+import { preferencesSchema as schema } from '@ludo.ninja/api';
+declare const useFetchUserInterests: () => {
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    userInterests: schema.IUserInterest[] | null;
+};
+export default useFetchUserInterests;

package/build/api/server-preferences/queries/useFetchUserInterests/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const useFetchUserInterests = () => {
+    const [userInterests, setInterests] = (0, react_1.useState)(null);
+    const { loading, error } = (0, client_1.useQuery)(api_1.preferencesSchema.FetchUserInterestsDocument, {
+        context: {
+            uri: api_1.hosts.preferencesHost,
+        },
+        onCompleted: ({ fetchUserInterests }) => {
+            setInterests(fetchUserInterests);
+        },
+        onError: () => {
+            setInterests(null);
+        },
+    });
+    return { loading, error, userInterests };
+};
+exports.default = useFetchUserInterests;

package/build/api/server-preferences/queries/useSearchResultBlockchainSelections/index.d.ts

@@ -0,0 +1,13 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import { ISelectInput } from '../../../../system/Forms/Selects/MobileSelect';
+export declare const prefetchSearchResultBlockchainSelections: (apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        fetchSearchResultBlockchainSelections: null;
+    };
+}>;
+export declare const useSearchResultBlockchainSelections: () => {
+    searchResultBlockchainSelectionsLoading: boolean;
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    searchResultBlockchainSelections: ISelectInput[] | null;
+};

package/build/api/server-preferences/queries/useSearchResultBlockchainSelections/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSearchResultBlockchainSelections = exports.prefetchSearchResultBlockchainSelections = void 0;
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const prefetchSearchResultBlockchainSelections = (apolloClient) => {
+    return apolloClient
+        .query({
+        query: api_1.preferencesSchema.FetchSearchResultBlockchainSelectionsDocument,
+        context: { uri: api_1.hosts.preferencesHost },
+        fetchPolicy: 'network-only',
+    })
+        .catch(() => {
+        return {
+            data: { fetchSearchResultBlockchainSelections: null },
+        };
+    });
+};
+exports.prefetchSearchResultBlockchainSelections = prefetchSearchResultBlockchainSelections;
+const useSearchResultBlockchainSelections = () => {
+    const [searchResultBlockchainSelections, setSearchResultBlockchainSelections,] = (0, react_1.useState)(null);
+    const { error, loading } = (0, client_1.useQuery)(api_1.preferencesSchema.FetchSearchResultBlockchainSelectionsDocument, {
+        context: {
+            uri: api_1.hosts.preferencesHost,
+        },
+        onCompleted: ({ fetchSearchResultBlockchainSelections }) => {
+            setSearchResultBlockchainSelections(fetchSearchResultBlockchainSelections);
+        },
+        onError: () => {
+            setSearchResultBlockchainSelections(null);
+        },
+    });
+    return {
+        searchResultBlockchainSelectionsLoading: loading,
+        loading,
+        error,
+        searchResultBlockchainSelections,
+    };
+};
+exports.useSearchResultBlockchainSelections = useSearchResultBlockchainSelections;

package/build/api/server-preferences/queries/useSearchResultCategorySelections/index.d.ts

@@ -0,0 +1,13 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import { preferencesSchema as schema } from '@ludo.ninja/api';
+export declare const prefetchSearchResultCategorySelections: (apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        fetchSearchResultCategorySelections: null;
+    };
+}>;
+declare const useSearchResultCategorySelections: () => {
+    categorySelectionsLoading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    searchResultCategorySelections: schema.Maybe<Pick<schema.ISelection, "label" | "name">>[] | null;
+};
+export default useSearchResultCategorySelections;

package/build/api/server-preferences/queries/useSearchResultCategorySelections/index.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prefetchSearchResultCategorySelections = void 0;
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const prefetchSearchResultCategorySelections = (apolloClient) => {
+    return apolloClient
+        .query({
+        query: api_1.preferencesSchema.FetchSearchResultCategorySelectionsDocument,
+        context: { uri: api_1.hosts.preferencesHost },
+        fetchPolicy: 'network-only',
+    })
+        .catch(() => {
+        return {
+            data: { fetchSearchResultCategorySelections: null },
+        };
+    });
+};
+exports.prefetchSearchResultCategorySelections = prefetchSearchResultCategorySelections;
+const useSearchResultCategorySelections = () => {
+    const [searchResultCategorySelections, setSearchResultCategorySelections] = (0, react_1.useState)(null);
+    const { error, loading } = (0, client_1.useQuery)(api_1.preferencesSchema.FetchSearchResultCategorySelectionsDocument, {
+        context: {
+            uri: api_1.hosts.preferencesHost,
+        },
+        onCompleted: ({ fetchSearchResultCategorySelections }) => {
+            setSearchResultCategorySelections(fetchSearchResultCategorySelections);
+        },
+        onError: () => {
+            setSearchResultCategorySelections(null);
+        },
+    });
+    return {
+        categorySelectionsLoading: loading,
+        error,
+        searchResultCategorySelections,
+    };
+};
+exports.default = useSearchResultCategorySelections;

package/build/api/server-preferences/queries/useSearchResultStatusSelections/index.d.ts

@@ -0,0 +1,14 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import { preferencesSchema as schema } from '@ludo.ninja/api';
+export declare const prefetchSearchResultStatusSelections: (apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        fetchSearchResultStatusSelections: null;
+    };
+}>;
+declare const useSearchResultStatusSelections: () => {
+    searchResultStatusSelectionsLoading: boolean;
+    loading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    searchResultStatusSelections: schema.Maybe<Pick<schema.ISelection, "label" | "name">>[] | null;
+};
+export default useSearchResultStatusSelections;

package/build/api/server-preferences/queries/useSearchResultStatusSelections/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prefetchSearchResultStatusSelections = void 0;
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const prefetchSearchResultStatusSelections = (apolloClient) => {
+    return apolloClient
+        .query({
+        query: api_1.preferencesSchema.FetchSearchResultStatusSelectionsDocument,
+        context: { uri: api_1.hosts.preferencesHost },
+        fetchPolicy: 'network-only',
+    })
+        .catch(() => {
+        return {
+            data: { fetchSearchResultStatusSelections: null },
+        };
+    });
+};
+exports.prefetchSearchResultStatusSelections = prefetchSearchResultStatusSelections;
+const useSearchResultStatusSelections = () => {
+    const [searchResultStatusSelections, setSearchResultStatusSelections] = (0, react_1.useState)(null);
+    const { error, loading } = (0, client_1.useQuery)(api_1.preferencesSchema.FetchSearchResultStatusSelectionsDocument, {
+        context: {
+            uri: api_1.hosts.preferencesHost,
+        },
+        onCompleted: ({ fetchSearchResultStatusSelections }) => {
+            setSearchResultStatusSelections(fetchSearchResultStatusSelections);
+        },
+        onError: () => {
+            setSearchResultStatusSelections(null);
+        },
+    });
+    return {
+        searchResultStatusSelectionsLoading: loading,
+        loading,
+        error,
+        searchResultStatusSelections,
+    };
+};
+exports.default = useSearchResultStatusSelections;

package/build/api/server-preferences/queries/useSearchResultTypeSelections/index.d.ts

@@ -0,0 +1,13 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client';
+import { preferencesSchema as schema } from '@ludo.ninja/api';
+export declare const prefetchSearchResultTypeSelections: (apolloClient: ApolloClient<NormalizedCacheObject>) => Promise<import("@apollo/client").ApolloQueryResult<any> | {
+    data: {
+        fetchSetsSearchResultTypeSelections: null;
+    };
+}>;
+export declare const useSearchResultTypeSelections: () => {
+    resultTypeSelectionsLoading: boolean;
+    error: import("@apollo/client").ApolloError | undefined;
+    data: any;
+    searchResultTypeSelections: schema.Maybe<Pick<schema.ISelection, "label" | "name">>[] | null;
+};

package/build/api/server-preferences/queries/useSearchResultTypeSelections/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSearchResultTypeSelections = exports.prefetchSearchResultTypeSelections = void 0;
+const react_1 = require("react");
+const client_1 = require("@apollo/client");
+const api_1 = require("@ludo.ninja/api");
+const prefetchSearchResultTypeSelections = (apolloClient) => {
+    return apolloClient
+        .query({
+        query: (0, client_1.gql) `
+        query FetchSetsSearchResultTypeSelections {
+          fetchSearchResultTypeSelections {
+            name
+            label
+          }
+        }
+      `,
+        context: { uri: api_1.hosts.preferencesHost },
+        fetchPolicy: 'network-only',
+    })
+        .catch(() => {
+        return {
+            data: { fetchSetsSearchResultTypeSelections: null },
+        };
+    });
+};
+exports.prefetchSearchResultTypeSelections = prefetchSearchResultTypeSelections;
+const useSearchResultTypeSelections = () => {
+    const [searchResultTypeSelections, setSearchResultTypeSelections] = (0, react_1.useState)(null);
+    const { data, error, loading } = (0, client_1.useQuery)(api_1.preferencesSchema.FetchSetsSearchResultTypeSelectionsDocument, {
+        context: {
+            uri: api_1.hosts.preferencesHost,
+        },
+        onCompleted: ({ fetchSetsSearchResultTypeSelections }) => {
+            setSearchResultTypeSelections(fetchSetsSearchResultTypeSelections);
+        },
+        onError: () => {
+            setSearchResultTypeSelections(null);
+        },
+    });
+    return {
+        resultTypeSelectionsLoading: loading,
+        error,
+        data,
+        searchResultTypeSelections,
+    };
+};
+exports.useSearchResultTypeSelections = useSearchResultTypeSelections;

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

@@ -4,8 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const react_1 = require("react");
-const getPageSizeAssets_1 = require("../../../../utils/getPageSizeAssets");
 const api_1 = require("@ludo.ninja/api");
+const getPageSizeAssets_1 = require("../../../../utils/getPageSizeAssets");
 const CreationEntity_1 = __importDefault(require("../../../../dto/CreationEntity"));
 const limit = 20;
 const useFindUserCreations = ({ ownerId, input, scrollTab, }) => {

package/build/system/Forms/DatePicker/index.d.ts

@@ -1,6 +1,4 @@
 import React from 'react';
-import 'react-calendar/dist/Calendar.css';
-import 'react-date-picker/dist/DatePicker.css';
 import { UseFormRegisterReturn } from 'react-hook-form';
 import { Control } from 'react-hook-form/dist/types/form';
 interface Props {

package/build/system/Forms/DatePicker/index.js

@@ -4,9 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const jsx_runtime_1 = require("react/jsx-runtime");
-require("react-calendar/dist/Calendar.css");
+// add imports to global css (next js - _app.tsx)
+// import 'react-calendar/dist/Calendar.css';
+// import 'react-date-picker/dist/DatePicker.css';
 const react_date_picker_1 = __importDefault(require("react-date-picker"));
-require("react-date-picker/dist/DatePicker.css");
 const react_hook_form_1 = require("react-hook-form");
 const styled_components_1 = __importDefault(require("styled-components"));
 const colors_1 = require("@ludo.ninja/ui/build/styles/colors");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ludo.ninja/components",
-  "version": "2.1.3",
+  "version": "2.1.5",
   "private": false,
   "main": "build/index.js",
   "types": "build/index.d.ts",