@helpdice/sdk 0.2.6 → 0.2.7

package/dist/index.js

@@ -1,23 +1,974 @@
-// @ts-ignore
-/// <reference types="styled-jsx" />
-// export { isAuth } from './utils/auth';
-export { getCookie } from "./utils/auth.js";
-export { getUrl } from "./config/route.js";
-export { default as Auth } from "./auth/index.js";
-export { default as Order } from "./order/index.js";
-export { default as Payment } from "./payment/index.js";
-export { default as Content } from "./content/index.js";
-export { default as Accounting } from "./accounting/index.js";
-export { default as Support } from "./support/index.js";
-export { default as Assets } from "./assets/index.js";
-export { default as Account } from "./account/index.js";
-export { default as shareUrl } from "./utils/share.js";
-export { default as Sales } from "./sales/index.js";
-export { default as Inventory } from "./inventory/index.js";
-export { default as Tools } from "./tools/index.js";
-export { default as Linkie } from "./linkie/index.js";
-export { getConfig, initializeSDK } from './config/index.js';
-// export { useUser, usePrivate, useAuth } from './hooks';
-// Types
-export * from './sales/types.js';
-//# sourceMappingURL=index.js.map
+import Cookies from 'js-cookie';
+import { jwtDecode } from 'jwt-decode';
+import firebase from 'firebase/compat/app';
+import CryptoJS from 'crypto-js';
+import axios from 'axios';
+import { GoogleAuthProvider, getAuth, signInWithPopup } from 'firebase/auth';
+
+// validateConfig
+function validateConfig(requiredKeys) {
+    const config = getConfig();
+    const missingKeys = requiredKeys.filter((key) => {
+        return !config[key]; // null, undefined, empty string → treated as missing
+    });
+    if (missingKeys.length > 0) {
+        throw new Error(`SDK configuration error: Missing required config value(s): ${missingKeys.join(', ')}\n` +
+            '👉 Please ensure these keys are set using setConfig({ ... }) before making requests.');
+    }
+}
+
+let config = {
+    tokenKey: '',
+    apiKey: null,
+    apiUrl: 'https://api.helpdice.com',
+    appUrl: '',
+    apisUrl: 'https://apis.helpdice.com',
+    environment: 'production',
+    firebase: undefined
+};
+function initializeSDK(newConfig) {
+    config = { ...config, ...newConfig };
+    validateConfig(['apiKey', 'tokenKey']);
+}
+function getFirebase() {
+    validateConfig(['firebase']);
+    const appConfig = getConfig();
+    if (appConfig.firebase) {
+        // if (firebase?.default != undefined) {
+        //   return firebase.default.initializeApp(appConfig.firebase)
+        // }
+        return firebase.initializeApp(appConfig.firebase);
+    }
+    throw new Error(`SDK configuration error: Firebase is not configured properly`);
+}
+function getConfig() {
+    return config;
+}
+
+const getCookie = (key = getConfig().tokenKey) => {
+    // console.log(Cookies.get(key));
+    if (key)
+        return Cookies.get(key);
+    return "";
+};
+const isAuth = () => !!getCookie();
+// export const getServerSideToken = (ctx: NextPageContext) => {
+// 	const { token } = parseCookies(ctx);
+// 	return token;
+// };
+
+/**
+ * Function to set encryption key
+ * @param {string} key - encryption key name
+ * @param {string} value string value to be set as encryption key
+ */
+function setEncryptionKey(key, value) {
+    if (value) {
+        const sha256Key = CryptoJS.SHA256(key).toString();
+        // console.log('setting key: ', key, value);
+        const sha256Data = CryptoJS.SHA256(value).toString();
+        localStorage.setItem(sha256Key, JSON.stringify(sha256Data));
+    }
+    else {
+        console.error("No data provided");
+    }
+}
+/**
+ * function to get the encryption key
+ * @param {string} - name of the key to get encryption key for
+ * @returns {string}
+ */
+// eslint-disable-next-line consistent-return
+function getEncryptionKey(key) {
+    try {
+        const shaKey = CryptoJS.SHA256(key).toString();
+        // console.log('getting key: ', key, localStorage.getItem(shaKey));
+        return localStorage.getItem(shaKey);
+    }
+    catch (err) {
+        console.error("something went wrong man hoho");
+    }
+}
+/**
+ * Funtion to store data in local storage
+ * Pass second argument as true if setting data for employee side
+ * @param {string} key key for the value to be stored
+ * @param {*} data actual data to be stored with the provided key
+ * @param {boolean} [useEmployeeKey] - flag to decide which encyption key to use, (employee's or admin's)
+ */
+function setDataInStorage(key, data) {
+    // Encrypt key
+    const shaKey = CryptoJS.SHA256(key).toString();
+    const encKeyName = "account_key";
+    const encryptionKey = getEncryptionKey(encKeyName);
+    // console.log('setting data: ', encryption_key, key, shaKey, data);
+    if (encryptionKey) {
+        // Encrypt data
+        const dataCipher = CryptoJS.AES.encrypt(JSON.stringify(data), encryptionKey).toString();
+        localStorage.setItem(shaKey, JSON.stringify(dataCipher));
+    }
+}
+/**
+ * Function to get data from local storage
+ * Pass second argument as true if getting data for employee side
+ * @param {string} key - key of the item to fetch from local storage
+ * @param {boolean} [useEmployeeKey] - flag to decide which encyption key to use, (employee's or admin's)
+ * @returns {*} value associated with the key
+ */
+// eslint-disable-next-line consistent-return
+function getDataFromStorage(key) {
+    try {
+        const shaKey = CryptoJS.SHA256(key).toString();
+        const encKeyName = "account_key";
+        const encryptionKey = getEncryptionKey(encKeyName);
+        // console.log(
+        //   'from getting data: ',
+        //   key,
+        //   'encryption-key',
+        //   typeof encryption_key,
+        //   encryption_key
+        // );
+        if (encryptionKey && shaKey) {
+            const ciphertext = JSON.parse(String(localStorage.getItem(shaKey)));
+            if (ciphertext) {
+                // Decrypt
+                const bytes = CryptoJS.AES.decrypt(ciphertext, encryptionKey);
+                const originalData = bytes.toString(CryptoJS.enc.Utf8);
+                // console.log('getting data: ', key, shaKey, originalData);
+                return JSON.parse(originalData);
+            }
+        }
+    }
+    catch (err) {
+        // console.error('Error getting data from storage boi boi');
+    }
+}
+/**
+ * Function to clear items from local storage
+ * @param {(string|string[])} keys - key to remove or array of keys
+ */
+// export function clearStorage(keys: string[]) {
+// 	try {
+// 		if (Array.isArray(keys)) {
+// 			keys.forEach((key) => {
+// 				const shaKey = CryptoJS.SHA256(key).toString();
+// 				localStorage.removeItem(shaKey);
+// 			});
+// 		} else if (typeof keys === "string") {
+// 			const shaKey = CryptoJS.SHA256(keys).toString();
+// 			localStorage.removeItem(shaKey);
+// 		}
+// 	} catch (err) {
+// 		console.error("Error clearing storage", err);
+// 	}
+// }
+function clearStorage(keys) {
+    try {
+        if (Array.isArray(keys)) {
+            for (const key of keys) {
+                const shaKey = CryptoJS.SHA256(key).toString();
+                localStorage.removeItem(shaKey);
+            }
+        }
+        else if (typeof keys === "string") {
+            const shaKey = CryptoJS.SHA256(keys).toString();
+            localStorage.removeItem(shaKey);
+        }
+    }
+    catch (err) {
+        console.error("Error clearing storage", err);
+    }
+}
+
+const TOKEN_KEY = "access-token";
+/* eslint-enable */
+
+const http = axios.create({
+    withCredentials: true,
+    headers: {
+        "Access-Control-Allow-Origin": "*",
+        "Content-Type": "application/json",
+    },
+});
+http.interceptors.request.use((config) => {
+    validateConfig(['apiKey', 'apiUrl']);
+    const { apiUrl } = getConfig();
+    config.baseURL = apiUrl;
+    if (config.headers) {
+        config.headers["Content-Type"] = "application/json";
+        config.headers.Authorization = `Bearer ${getCookie()}` || "";
+        config.headers["HB-API-KEY"] =
+            `Bearer ${getConfig().apiKey}` || "";
+    }
+    return config;
+}, Promise.reject);
+const post = (endpoint, data, config) => new Promise((resolve, reject) => http
+    .post(endpoint, data, config)
+    .then(resolve)
+    .catch((e) => reject(e.response?.data)));
+const put = (endpoint, data, config) => new Promise((resolve, reject) => http
+    .put(endpoint, data, config)
+    .then(resolve)
+    .catch((e) => reject(e.response?.data)));
+const get = (endpoint, config) => {
+    // console.log('Get Request Config :', config);
+    return new Promise((resolve, reject) => http
+        .get(endpoint, config)
+        .then(resolve)
+        .catch((e) => reject(e.response?.data)));
+};
+/* ======================================================================================================= */
+/* ------------------------------------ For Linkie App --------------------------------------------------- */
+/* ======================================================================================================= */
+const chttp = axios.create({
+    withCredentials: true,
+    headers: {
+        "Access-Control-Allow-Origin": "*",
+        "Content-Type": "application/json",
+    },
+});
+chttp.interceptors.request.use((config) => {
+    validateConfig(['apiKey', 'tokenKey', 'linkieUrl']);
+    const { linkieUrl } = getConfig();
+    config.baseURL = linkieUrl;
+    if (config.headers) {
+        config.headers["Content-Type"] = "application/json";
+        config.headers.Authorization = localStorage.getItem(TOKEN_KEY) || "";
+        config.headers["HB-API-KEY"] =
+            `Bearer ${getConfig().apiKey}` || "";
+    }
+    return config;
+}, Promise.reject);
+// chttp.interceptors.response.use(
+// 	(response) => response,
+// 	async (error) => {
+// 		if (error.code === "ERR_NETWORK") {
+// 			return Promise.reject(error);
+// 		}
+// 		const refreshToken = localStorage.getItem(REFRESH_TOKEN_KEY);
+// 		if (!refreshToken) {
+// 			return Promise.reject(error);
+// 		}
+// 		// const originalRequest = error.config;
+// 		// if (error.response.status === 401 && !originalRequest._retry) {
+// 		//   originalRequest._retry = true;
+// 		//   if (http.defaults.headers) {
+// 		//     http.defaults.headers.Authorization = `Bearer ${refreshToken}`;
+// 		//   }
+// 		//   try {
+// 		//     const res = await post('auth/token');
+// 		//     const { access_token, threshold } = res.data;
+// 		//     // handleItem(TOKEN_KEY, access_token);
+// 		//     // handleItem(TOKEN_THRESHOLD_KEY, setThreshold(threshold));
+// 		//     if (http.defaults.headers) {
+// 		//       http.defaults.headers.Authorization = access_token;
+// 		//     }
+// 		//     return await http(originalRequest);
+// 		//   } catch (reason) {
+// 		//     return Promise.reject(reason);
+// 		//   }
+// 		// }
+// 		return Promise.reject(error);
+// 	},
+// );
+const linkiePost = (endpoint, data, config) => new Promise((resolve, reject) => chttp
+    .post(endpoint, data, config)
+    .then(resolve)
+    .catch((e) => reject(e.response?.data)));
+
+// The fetchDataWithCallbacks function that accepts a Promise and a callbacks object
+async function handler$1(promise, callbacks) {
+    // Destructure callbacks from the object
+    const { onFetching, onSuccess, onError, onSettled } = callbacks ?? {};
+    // Call the onFetching callback before making the request
+    if (onFetching)
+        onFetching();
+    // Handle the Promise passed as an argument
+    promise
+        .then((response) => {
+        // Call the onSuccess callback if the Promise resolves successfully
+        if (onSuccess)
+            onSuccess({
+                data: response.data,
+                status: response.status,
+                statusText: response.statusText,
+            });
+    })
+        .catch((error) => {
+        // Call the onError callback if the Promise is rejected
+        if (onError)
+            onError(error);
+    })
+        .finally(() => {
+        // Call the onSettled callback after the Promise is settled
+        if (onSettled)
+            onSettled();
+    });
+}
+
+const account = {
+    v1: {
+        profile: "profile",
+    },
+};
+
+const accounting = {
+    v1: {
+        item: "item",
+        items: "items",
+        invoice: "invoice",
+        submit_invoice: "invoice/submit",
+        invoices: "invoices",
+        item_categories: "item/category",
+        item_brands: "item/brand",
+    },
+};
+
+const assets = {
+    v1: {
+        imagePlaceholder: "images/image-placeholder.webp",
+        avatar: "images/avatar.webp",
+    },
+};
+
+const auth = {
+    v1: {
+        signin: "signin",
+        register: "signup",
+        signup: "register",
+        logout: "logout",
+        auth_with_token: "authenticate",
+        auth_with_key: "verify",
+        reset_password: "recovery-password",
+        change_password: "change-password"
+    },
+};
+
+const cms = {
+    v1: {
+        article: "article",
+        articles: "articles",
+        articleCategories: "article/categories",
+        mcq: "mcq",
+        mcqs: "mcqs",
+        all_mcqs: "mcqs/all",
+        mcqCategories: "mcq/categories",
+        qna: "qna",
+        qnas: "qnas",
+        qnaCategories: "qna/categories",
+    },
+};
+
+const inventory = {
+    v1: {
+        store: "store",
+        store_products: "store/products",
+    },
+};
+
+const linkie = {
+    v1: {
+        shorten: "shorten",
+    },
+};
+
+const payment = {
+    v1: {
+        create: "",
+        verify: "verify",
+    },
+};
+
+const sales = {
+    v1: {
+        addLead: "lead"
+    },
+};
+
+const support = {
+    v1: {
+        ticket: "ticket",
+        tickets: "tickets",
+        newsletter: "newsletter",
+    },
+};
+
+const tools = {
+    v1: {
+        exchangeRates: "exchange-rates",
+    },
+};
+
+const urls = {
+    auth,
+    cms,
+    account,
+    accounting,
+    support,
+    assets,
+    payment,
+    inventory,
+    tools,
+    sales,
+    linkie
+};
+// Function to get the URL dynamically based on category, version, and action
+function getUrl(category, version, action, omitCategory = false) {
+    const categoryData = urls[category]; // Access the correct category dynamically
+    if (categoryData) {
+        const versionData = categoryData[version]; // Access the correct version dynamically
+        // console.log(versionData?.[action]);
+        if (versionData !== undefined) {
+            console.log(versionData[action]);
+            if (omitCategory) {
+                return `/api/${version}/${versionData[action]}`;
+            }
+            return `/api/${version}/${category}/${versionData[action]}`; // Construct the URL
+        }
+        throw new Error(`Invalid action: ${action} for version: ${version} in category: ${category}`);
+    }
+    throw new Error(`Invalid category: ${category}`);
+}
+
+const logout = (data, { config, onFetching, onSuccess, onError, onSettled, }) => {
+    return handler$1(post(getUrl("auth", "v1", "logout"), { ...data, fcm_token: getDataFromStorage("fcm_token") }, config), {
+        onFetching: () => onFetching?.(),
+        onError: (error) => onError?.(error),
+        onSuccess: (data) => {
+            clearStorage(["accountAccessToken", "accountInfo", "account_key"]);
+            onSuccess?.(data);
+            window.location.href = "/";
+        },
+        onSettled: () => onSettled?.(),
+    });
+};
+
+const register = (data, { config, onFetching, onSuccess, onError, onSettled, }) => {
+    return handler$1(post(getUrl("auth", "v1", "register"), data, config), {
+        onFetching: () => onFetching?.(),
+        onError: (error) => onError?.(error),
+        onSuccess: (data) => onSuccess?.(data),
+        onSettled: () => onSettled?.(),
+    });
+};
+
+const signup = (data, { config, onFetching, onSuccess, onError, onSettled, }) => {
+    return handler$1(post(getUrl("auth", "v1", "signup"), data, config), {
+        onFetching: () => onFetching?.(),
+        onError: (error) => onError?.(error),
+        onSuccess: (data) => onSuccess?.(data),
+        onSettled: () => onSettled?.(),
+    });
+};
+
+// import signin from "./signin";
+// Function to handle Google Sign-In
+async function signInWithGoogle({ onSuccess, onError, onFetching, onSettled, }) {
+    try {
+        const provider = new GoogleAuthProvider();
+        const auth = getAuth(getFirebase());
+        signInWithPopup(auth, provider)
+            .then((result) => {
+            // This gives you a Google Access Token. You can use it to access the Google API.
+            const credential = GoogleAuthProvider.credentialFromResult(result);
+            // const token = credential?.accessToken;
+            // The signed-in user info.
+            const user = result.user;
+            // console.log(user);
+            return signup({
+                provider: "Google",
+                uid: user.uid,
+                name: String(user.displayName),
+                email: String(user.email),
+                username: String(user.email),
+                password: user.uid.substring(0, user.uid.length / 2),
+                // token: token,
+                today: new Date(),
+            }, {
+                onFetching: () => onFetching?.(),
+                onError: (error) => onError?.(error),
+                onSuccess: (data) => onSuccess?.(data),
+                onSettled: () => onSettled?.(),
+            });
+        })
+            .catch((error) => {
+            onError?.(error);
+            return Promise.reject("Something Went Wrong");
+            // Handle Errors here.
+            // const errorCode = error.code;
+            // const errorMessage = error.message;
+            // The email of the user's account used.
+            // const email = error.customData.email;
+            // The AuthCredential type that was used.
+            // const credential = GoogleAuthProvider.credentialFromError(error);
+            // ...
+        });
+    }
+    catch (err) {
+        onError?.(err);
+    }
+}
+
+const signin = (data, { config, onFetching, onSuccess, onError, onSettled, }) => {
+    return handler$1(post(getUrl("auth", "v1", "signin"), data, config), {
+        onFetching: () => onFetching?.(),
+        onError: (error) => onError?.(error),
+        onSuccess: (data) => onSuccess?.(data),
+        onSettled: () => onSettled?.(),
+    });
+};
+
+const authWithToken = (data, { config, onFetching, onSuccess, onError, onSettled, }) => {
+    return handler$1(post(getUrl("auth", "v1", "auth_with_token"), data, config), {
+        onFetching: () => onFetching?.(),
+        onError: (error) => onError?.(error),
+        onSuccess: (data) => onSuccess?.(data),
+        onSettled: () => onSettled?.(),
+    });
+};
+
+const authWithKey = (data, { config, onFetching, onSuccess, onError, onSettled, }) => {
+    return handler$1(post(getUrl("auth", "v1", "auth_with_key"), data, config), {
+        onFetching: () => onFetching?.(),
+        onError: (error) => onError?.(error),
+        onSuccess: (data) => onSuccess?.(data),
+        onSettled: () => onSettled?.(),
+    });
+};
+
+const resetPassword = (data, { config, onFetching, onSuccess, onError, onSettled, }) => {
+    return handler$1(post(getUrl("auth", "v1", "reset_password"), data, config), {
+        onFetching: () => onFetching?.(),
+        onError: (error) => onError?.(error),
+        onSuccess: (data) => onSuccess?.(data),
+        onSettled: () => onSettled?.(),
+    });
+};
+
+const Auth = {
+    signIn: signin,
+    signUp: signup,
+    register,
+    resetPassword,
+    signInWithGoogle,
+    saveTokenToCookie: (token) => {
+        validateConfig(['tokenKey']);
+        const { tokenKey } = getConfig();
+        if (tokenKey) {
+            Cookies.set(tokenKey, token, { expires: 900000 });
+        }
+        window.location.href = "/";
+    },
+    saveTokenToStorage: (token) => {
+        const accountInfo = jwtDecode(token);
+        if (accountInfo) {
+            setEncryptionKey("account_key", accountInfo._id + accountInfo.createdAt);
+            setDataInStorage("accountAccessToken", token);
+            setDataInStorage("accountInfo", accountInfo);
+        }
+    },
+    getTokenFromStorage: () => {
+        return getDataFromStorage("accountAccessToken");
+    },
+    getUserFromStrorage: () => {
+        return getDataFromStorage("accountInfo");
+    },
+    /**
+     * Action to update stored admin info in the redux
+     * @param {string | object} key key or an object with key: value of the fields to be updated
+     * @param {any} value value of the field to be updated (only if the key passed is of type string)
+     */
+    updateUserInfo: (key, value) => () => {
+        console.log("typeof key: ", typeof key, key);
+        try {
+            // console.log(key);
+            const accountInfo = getDataFromStorage("accountInfo");
+            if (typeof key === "object") {
+                let updatedInfo = { ...accountInfo };
+                // for..of
+                for (const [ky, value] of Object.entries(key)) {
+                    updatedInfo = { ...updatedInfo, [ky]: value };
+                }
+                // console.log(updatedInfo);
+                setDataInStorage("accountInfo", updatedInfo);
+            }
+            else if (typeof key === "string") {
+                if (value) {
+                    setDataInStorage("accountInfo", { ...accountInfo, [key]: value });
+                }
+                else {
+                    console.error("Value is not provided for the given key to update admin info");
+                }
+            }
+        }
+        catch (error) {
+            console.error("update logo action ", error);
+        }
+    },
+    isAuthenticated: (cookie) => {
+        if (cookie) {
+            return isAuth();
+        }
+        return getDataFromStorage("accountAccessToken") !== undefined;
+    },
+    // getServerToken: (ctx: NextPageContext) => getServerSideToken(ctx),
+    logout,
+    Server: {
+        authWithToken,
+        authWithKey
+    }
+};
+
+const create = (data, { config, onFetching, onSuccess, onError, onSettled, }) => {
+    return handler$1(post(getUrl("order", "v1", "create"), data, config), {
+        onFetching: () => onFetching?.(),
+        onError: (error) => onError?.(error),
+        onSuccess: (data) => onSuccess?.(data),
+        onSettled: () => onSettled?.(),
+    });
+};
+
+const Order = {
+    create,
+};
+
+const handler = ({ promise, onLoading = () => { }, onSuccess = () => { }, onError = () => { }, onSettled = () => { }, onProgress = () => { }, }) => {
+    // Call onLoading at the start to show loading state
+    onLoading(true);
+    // Handling the passed promise
+    promise
+        .then((response) => {
+        // Show success state
+        console.log("Request Success:", response);
+        // Execute success callback if provided
+        if (onSuccess) {
+            onSuccess(response.data);
+        }
+    })
+        .catch((error) => {
+        // Show error state
+        console.error("Request Error:", error);
+        // Execute error callback if provided
+        if (onError) {
+            onError(error);
+        }
+    })
+        .finally(() => {
+        // Execute settled callback (on success or error)
+        if (onSettled) {
+            onSettled();
+        }
+        // Call onLoading to hide loading indicator after completion
+        onLoading(false);
+        // Hide loading indicator
+        console.log("Request Completed");
+    });
+};
+
+function start(data, { config = null, onLoading = () => { }, onSuccess = () => { }, onError = () => { }, onSettled = () => { }, } = {}) {
+    return handler({
+        promise: post(getUrl("payment", "v1", "create"), {
+            ...data,
+            method: {
+                label: data.paymentService,
+                currency: data.currency,
+            },
+        }, config || undefined),
+        onLoading,
+        onError: (error) => onError(error),
+        onSuccess: (responseData) => {
+            if (responseData?.method === "Razor Pay") {
+                const options = responseData.options;
+                options.handler = async (response) => {
+                    // console.log("Payment Success:", response);
+                    onSuccess(response);
+                    // Validation call (if needed)
+                };
+                const rzp1 = new window.Razorpay(options);
+                rzp1.on("payment.failed", (response) => {
+                    onError(response);
+                });
+                rzp1.open();
+            }
+        },
+        onSettled,
+    });
+}
+
+const verify = (data, { config, onFetching, onSuccess, onError, onSettled, }) => {
+    return handler$1(post(getUrl("payment", "v1", "verify"), data, config), {
+        onFetching: () => onFetching?.(),
+        onError: (error) => onError?.(error),
+        onSuccess: (data) => onSuccess?.(data),
+        onSettled: () => onSettled?.(),
+    });
+};
+
+const Payment = {
+    start,
+    verify,
+};
+
+const Content = {
+    article: (slug) => get(getUrl("cms", "v1", "article"), {
+        params: {
+            slug,
+        },
+    }),
+    articles: (config) => get(getUrl("cms", "v1", "articles"), config),
+    articleCategories: (config) => get(getUrl("cms", "v1", "articleCategories"), config),
+    mcq: (slug) => get(getUrl("cms", "v1", "mcq"), {
+        params: {
+            slug,
+        },
+    }),
+    mcqs: (config) => get(getUrl("cms", "v1", "mcqs"), config),
+    allMcqs: (config) => get(getUrl("cms", "v1", "all_mcqs"), config),
+    mcqsCategories: (config) => get(getUrl("cms", "v1", "mcqCategories"), config),
+    qna: (slug) => get(getUrl("cms", "v1", "qna"), {
+        params: {
+            slug,
+        },
+    }),
+    qnas: (config) => get(getUrl("cms", "v1", "qnas"), config),
+    qnasCategories: (config) => get(getUrl("cms", "v1", "qnaCategories"), config),
+};
+
+const createInvoice = (data, { config, onFetching, onSuccess, onError, onSettled, }) => {
+    return handler$1(post(getUrl("accounting", "v1", "invoice"), data, config), {
+        onFetching: () => onFetching?.(),
+        onError: (error) => onError?.(error),
+        onSuccess: (data) => onSuccess?.(data),
+        onSettled: () => onSettled?.(),
+    });
+};
+
+const submitInvoice = (data, { config, onFetching, onSuccess, onError, onSettled, }) => {
+    return handler$1(post(getUrl("accounting", "v1", "submit_invoice"), data, config), {
+        onFetching: () => onFetching?.(),
+        onError: (error) => onError?.(error),
+        onSuccess: (data) => onSuccess?.(data),
+        onSettled: () => onSettled?.(),
+    });
+};
+
+const updateInvoice = (data, { config, onFetching, onSuccess, onError, onSettled, }) => {
+    return handler$1(put(getUrl("accounting", "v1", "invoice"), data, config), {
+        onFetching: () => onFetching?.(),
+        onError: (error) => onError?.(error),
+        onSuccess: (data) => onSuccess?.(data),
+        onSettled: () => onSettled?.(),
+    });
+};
+
+const Accounting = {
+    item: (slug) => get(getUrl("accounting", "v1", "item"), {
+        params: {
+            slug,
+        },
+    }),
+    items: (config) => get(getUrl("accounting", "v1", "items"), config),
+    createInvoice,
+    updateInvoice,
+    invoices: (config) => get(getUrl("accounting", "v1", "invoices"), config),
+    submitInvoice,
+    itemCategories: () => get(getUrl("accounting", "v1", "item_categories")),
+    itemBrands: () => get(getUrl("accounting", "v1", "item_brands")),
+};
+
+const newsletter = (data, { config, onFetching, onSuccess, onError, onSettled, }) => {
+    return handler$1(post(getUrl("support", "v1", "newsletter"), data, config), {
+        onFetching: () => onFetching?.(),
+        onError: (error) => onError?.(error),
+        onSuccess: (data) => onSuccess?.(data),
+        onSettled: () => onSettled?.(),
+    });
+};
+
+const ticket = (data, { config, onFetching, onSuccess, onError, onSettled, }) => {
+    return handler$1(post(getUrl("support", "v1", "ticket"), data, config), {
+        onFetching: () => onFetching?.(),
+        onError: (error) => onError?.(error),
+        onSuccess: (data) => onSuccess?.(data),
+        onSettled: () => onSettled?.(),
+    });
+};
+
+const Support = {
+    ticket,
+    newsletter,
+    tickets: (config) => get(getUrl("support", "v1", "tickets"), config),
+};
+
+const Assets = {
+    images: {
+        imagePlaceholder: getConfig().apiUrl + getUrl("assets", "v1", "imagePlaceholder"),
+        avatar: getConfig().apiUrl + getUrl("assets", "v1", "avatar"),
+    },
+};
+
+const updateProfile = (data, { config, onFetching, onSuccess, onError, onSettled }) => {
+    return handler$1(put(getUrl("account", "v1", "profile"), data, config), {
+        onFetching: () => onFetching?.(),
+        onError: (error) => onError?.(error),
+        onSuccess: (data) => onSuccess?.(data),
+        onSettled: () => onSettled?.(),
+    });
+};
+
+const Account = {
+    profile: (id) => get(getUrl("account", "v1", "profile"), {
+        params: {
+            id,
+        },
+    }),
+    updateProfile,
+};
+
+function shareUrl(title, url) {
+    // URL encoding to ensure special characters are handled properly
+    const encodedTitle = encodeURIComponent(title);
+    const encodedUrl = encodeURIComponent(url);
+    const target = "_blank";
+    const dimension = "width=600,height=400";
+    // Social media share URLs
+    const shareLinks = {
+        facebook: `https://www.facebook.com/sharer/sharer.php?u=${encodedUrl}`,
+        twitter: `https://twitter.com/intent/tweet?text=${encodedTitle}&url=${encodedUrl}`,
+        linkedin: `https://www.linkedin.com/sharing/share-offsite/?url=${encodedUrl}`,
+        whatsapp: `https://api.whatsapp.com/send?text=${encodedTitle} ${encodedUrl}`,
+        pinterest: `https://www.pinterest.com/pin/create/button/?url=${encodedUrl}&description=${encodedTitle}`,
+    };
+    return {
+        facebook: () => window.open(shareLinks.facebook, target, dimension),
+        twitter: () => window.open(shareLinks.twitter, target, dimension),
+        linkedin: () => window.open(shareLinks.linkedin, target, dimension),
+        whatsapp: () => window.open(shareLinks.whatsapp, target, dimension),
+        pinterest: () => window.open(shareLinks.pinterest, target, dimension),
+    };
+}
+
+function addLead(data, { config = null, onLoading = () => { }, onSuccess = () => { }, onError = () => { }, onSettled = () => { }, } = {}) {
+    return handler({
+        promise: post(getUrl("sales", "v1", "addLead"), {
+            ...data
+        }, config || undefined),
+        onLoading,
+        onError: (error) => onError(error),
+        onSuccess: (responseData) => {
+            onSuccess(responseData);
+        },
+        onSettled,
+    });
+}
+
+const Sales = {
+    addLead,
+};
+
+const Inventory = {
+    getStoreById: (id) => get(getUrl("inventory", "v1", "store"), {
+        params: {
+            id,
+        },
+    }),
+    getStoreBySlug: (slug) => get(getUrl("inventory", "v1", "store"), {
+        params: {
+            slug,
+        },
+    }),
+    getStoreProducts: (slug, category, brand, price, search) => get(getUrl("inventory", "v1", "store_products"), {
+        params: {
+            slug,
+            category,
+            brand,
+            price,
+            search,
+        },
+    }),
+};
+
+const exchangeRates = (data, { config, onFetching, onSuccess, onError, onSettled, }) => {
+    return handler$1(get(getUrl("tools", "v1", "exchangeRates"), config), {
+        onFetching: () => onFetching?.(),
+        onError: (error) => onError?.(error),
+        onSuccess: (data) => onSuccess?.(data),
+        onSettled: () => onSettled?.(),
+    });
+};
+// export async function convertCurrency(amount: number, fromCurrency?: string, toCurrency?: string) {
+//     try {
+//         const rates = await getExchangeRates(fromCurrency);
+//         if (!rates[toCurrency]) {
+//             throw new Error(`Currency ${toCurrency} is not available.`);
+//         }
+//         const convertedAmount = (amount * rates[toCurrency]).toFixed(2);
+//         return convertedAmount;
+//     } catch (error) {
+//         console.error('Error converting currency:', error);
+//         throw error;
+//     }
+// }
+
+const Tools = {
+    exchangeRates,
+};
+
+const shortUrl = (data, { config, onFetching, onSuccess, onError, onSettled, }) => {
+    return handler$1(linkiePost(getUrl("linkie", "v1", "shorten", true), data, config), {
+        onFetching: () => onFetching?.(),
+        onError: (error) => onError?.(error),
+        onSuccess: (data) => onSuccess?.(data),
+        onSettled: () => onSettled?.(),
+    });
+};
+
+// import cookie from "js-cookie";
+// import { jwtDecode } from "jwt-decode";
+// import type { NextPageContext } from "next";
+// import { getConfig } from "../config/index";
+// import { isAuth } from "../utils/auth";
+// import {
+// 	getDataFromStorage,
+// 	setDataInStorage,
+// 	setEncryptionKey,
+// } from "../utils/localStorage";
+const Linkie = {
+    shortUrl
+};
+
+const getCities = ({ config, onFetching, onSuccess, onError, onSettled }) => {
+    return handler$1(get(`${getConfig().apisUrl}/api/countries/v1/city`, config), {
+        onFetching: () => onFetching?.(),
+        onError: (error) => onError?.(error),
+        onSuccess: (data) => onSuccess?.(data),
+        onSettled: () => onSettled?.(),
+    });
+};
+
+const getCountries = ({ config, onFetching, onSuccess, onError, onSettled }) => {
+    return handler$1(get(`${getConfig().apisUrl}/api/countries/v1`, config), {
+        onFetching: () => onFetching?.(),
+        onError: (error) => onError?.(error),
+        onSuccess: (data) => onSuccess?.(data),
+        onSettled: () => onSettled?.(),
+    });
+};
+
+const getStates = ({ config, onFetching, onSuccess, onError, onSettled }) => {
+    return handler$1(get(`${getConfig().apisUrl}/api/countries/v1/state`, config), {
+        onFetching: () => onFetching?.(),
+        onError: (error) => onError?.(error),
+        onSuccess: (data) => onSuccess?.(data),
+        onSettled: () => onSettled?.(),
+    });
+};
+
+const Apis = {
+    getCountries,
+    getStates,
+    getCities
+};
+
+export { Account, Accounting, Apis, Assets, Auth, Content, Inventory, Linkie, Order, Payment, Sales, Support, Tools, getConfig, getCookie, getUrl, initializeSDK, shareUrl };
+//# sourceMappingURL=index.js.map