@bindu-dashing/dam-solution-v2 5.8.6

package/build/hocs/helpers.js

@@ -0,0 +1,177 @@
+import dayjs from "dayjs";
+import { first, get, last, split, toLower, toUpper } from "lodash";
+import { DATE_FORMAT } from "./appConstants";
+export const getProfileName = (name) => {
+    return name
+        ? name
+            .split(" ")
+            .map((word) => { var _a; return (_a = word === null || word === void 0 ? void 0 : word[0]) === null || _a === void 0 ? void 0 : _a.toUpperCase(); })
+            .join("")
+        : "";
+};
+// export const humanFileSize = (size) => {
+//   var i = size == 0 ? 0 : Math.floor(Math.log(size) / Math.log(1024));
+//   return {
+//     size: (size / Math.pow(1024, i)).toFixed(2) * 1,
+//     sizeType: ["B", "kB", "MB", "GB", "TB"][i],
+//   };
+// };
+export function getProfileInitials(name) {
+    if (!name)
+        return "";
+    return name
+        .split(" ")
+        .map((word) => word.charAt(0).toUpperCase())
+        .join("");
+}
+export const addQueryParams = (params) => {
+    const paramStrings = Object.keys(params).reduce((acc, key) => {
+        const value = params[key];
+        let valueString;
+        if (typeof value === "object" && value !== null) {
+            valueString = encodeURIComponent(JSON.stringify(value));
+        }
+        else {
+            valueString = encodeURIComponent(value);
+        }
+        acc.push(`${key}=${valueString}`);
+        return acc;
+    }, []);
+    return paramStrings.join("&");
+};
+export const getProfile = (name) => {
+    const words = split(name, " ");
+    const firstName = first(words);
+    const lastName = last(words);
+    if (get(words, "length") > 1) {
+        return toUpper(first(firstName)) + toUpper(first(lastName));
+    }
+    else {
+        return toUpper(first(firstName));
+    }
+};
+export const formatBytes = (bytes, decimals = 2) => {
+    if (!bytes || bytes === 0)
+        return "0 Bytes";
+    const k = 1024;
+    const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    const value = parseFloat((bytes / Math.pow(k, i)).toFixed(decimals));
+    return `${value} ${sizes[i]}`;
+};
+export const getDateRangeFromKey = (key) => {
+    const today = dayjs();
+    switch (key) {
+        case "today":
+            return {
+                startDate: today.format(DATE_FORMAT),
+                endDate: today.format(DATE_FORMAT),
+            };
+        case "last7":
+            return {
+                startDate: today.subtract(7, "day").format(DATE_FORMAT),
+                endDate: today.format(DATE_FORMAT),
+            };
+        case "last30":
+            return {
+                startDate: today.subtract(30, "day").format(DATE_FORMAT),
+                endDate: today.format(DATE_FORMAT),
+            };
+        case "thisYear":
+            return {
+                startDate: today.startOf("year").format(DATE_FORMAT),
+                endDate: today.endOf("year").format(DATE_FORMAT),
+            };
+        case "lastYear":
+            const lastYear = today.subtract(1, "year");
+            return {
+                startDate: lastYear.startOf("year").format(DATE_FORMAT),
+                endDate: lastYear.endOf("year").format(DATE_FORMAT),
+            };
+        default:
+            return {};
+    }
+};
+export const getBaseUrl = (appType) => {
+    switch (appType) {
+        case "reactJs":
+            return process.env.REACT_APP_API_URL || "https://yjeregc921.execute-api.ap-south-1.amazonaws.com/staging/v1";
+        case "nextJs":
+            return process.env.NEXT_PUBLIC_API_URL || "https://yjeregc921.execute-api.ap-south-1.amazonaws.com/staging/v1";
+        default:
+            return "https://yjeregc921.execute-api.ap-south-1.amazonaws.com/staging/v1";
+    }
+};
+export const getRelativeTime = (timestamp) => {
+    const now = new Date();
+    const created = new Date(timestamp);
+    const diff = Math.floor((now.getTime() - created.getTime()) / 1000); // in seconds
+    const minutes = Math.floor(diff / 60);
+    const hours = Math.floor(diff / 3600);
+    const days = Math.floor(diff / 86400);
+    const weeks = Math.floor(diff / (86400 * 7));
+    const years = Math.floor(diff / (86400 * 365));
+    if (diff < 60)
+        return "just now";
+    if (minutes < 60)
+        return `${minutes} min${minutes > 1 ? "s" : ""} ago`;
+    if (hours < 24)
+        return `${hours} hour${hours > 1 ? "s" : ""} ago`;
+    if (days < 7)
+        return `${days} day${days > 1 ? "s" : ""} ago`;
+    if (weeks < 52)
+        return `${weeks} week${weeks > 1 ? "s" : ""} ago`;
+    return `${years} year${years > 1 ? "s" : ""} ago`;
+};
+export const getReadableFileType = (file) => {
+    const mimetype = get(file, "mimetype", "");
+    const fileName = get(file, "name", "");
+    const extension = toLower(fileName.split(".").pop() || "");
+    const typeMap = {
+        "image/png": "PNG image",
+        "image/jpeg": "JPEG image",
+        "image/jpg": "JPG image",
+        "image/webp": "WEBP image",
+        "image/gif": "GIF image",
+        "application/pdf": "PDF document",
+        "application/msword": "Word document",
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "Word document",
+        "application/vnd.ms-excel": "Excel spreadsheet",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "Excel spreadsheet",
+        "text/plain": "Text file",
+        "application/zip": "ZIP archive",
+        "application/json": "JSON file",
+    };
+    // Check mimetype first
+    const typeFromMime = get(typeMap, mimetype);
+    if (typeFromMime)
+        return typeFromMime;
+    // Final fallback based on extension
+    return extension ? `${extension.toUpperCase()} file` : "Unknown file";
+};
+export const humanFileSize = (size) => {
+    var i = size == 0 ? 0 : Math.floor(Math.log(size) / Math.log(1024));
+    return {
+        size: (size / Math.pow(1024, i)).toFixed(2) * 1,
+        sizeType: ["B", "kB", "MB", "GB", "TB"][i],
+    };
+};
+export const getFormattedValue = (outputFormatData, fileUrl, item) => {
+    const value = outputFormatData === null || outputFormatData === void 0 ? void 0 : outputFormatData.reduce((acc, field) => {
+        var _a;
+        if (field === null || field === void 0 ? void 0 : field.required) {
+            if ((field === null || field === void 0 ? void 0 : field.name) == "File URL") {
+                acc = (field === null || field === void 0 ? void 0 : field.separator) ? acc + fileUrl + " " : acc + fileUrl;
+            }
+            else {
+                const fieldValue = (_a = item === null || item === void 0 ? void 0 : item[field === null || field === void 0 ? void 0 : field.fieldId]) === null || _a === void 0 ? void 0 : _a.toString();
+                acc = acc + ((fieldValue === null || fieldValue === void 0 ? void 0 : fieldValue.trim()) ? fieldValue : "");
+            }
+            if (field === null || field === void 0 ? void 0 : field.separator) {
+                acc = acc + (field === null || field === void 0 ? void 0 : field.separator);
+            }
+        }
+        return acc;
+    }, "");
+    return value ? value : fileUrl;
+};

package/build/index.d.ts

@@ -0,0 +1,11 @@
+import ImagePicker from "./ImagePicker";
+import "./style.css";
+import AssetTypes from "./AssetType";
+import MyDrive from "./MyDrive";
+import CreateClient from "./CreateClient";
+import RefreshKey from "./RefreshKey";
+import ImagePickerFilters from "./ImagePickerFilters";
+import ShoesView from "./ShoesView";
+import PenView from "./PenView";
+import BookView from "./BookView";
+export { AssetTypes, MyDrive, CreateClient, ImagePicker, RefreshKey, ImagePickerFilters, ShoesView, PenView, BookView };

package/build/index.js

@@ -0,0 +1,11 @@
+import ImagePicker from "./ImagePicker";
+import "./style.css";
+import AssetTypes from "./AssetType";
+import MyDrive from "./MyDrive";
+import CreateClient from "./CreateClient";
+import RefreshKey from "./RefreshKey";
+import ImagePickerFilters from "./ImagePickerFilters";
+import ShoesView from "./ShoesView";
+import PenView from "./PenView";
+import BookView from "./BookView";
+export { AssetTypes, MyDrive, CreateClient, ImagePicker, RefreshKey, ImagePickerFilters, ShoesView, PenView, BookView };

package/build/react-query/hooks/brand-hooks.d.ts

@@ -0,0 +1,3 @@
+import { QueryClient } from "react-query";
+export declare const getCurrentBrandData: (queryClient: QueryClient, brandId: string) => {} | null;
+export declare const getCurrentBrandUsers: (queryClient: QueryClient, brandId: string) => never[];

package/build/react-query/hooks/brand-hooks.js

@@ -0,0 +1,10 @@
+import { QueryKeys } from "../../utilities/constants/queryKeys";
+import { get } from "lodash";
+export const getCurrentBrandData = (queryClient, brandId) => {
+    const brandData = queryClient.getQueryData([QueryKeys.BRAND, brandId]);
+    return brandData || null;
+};
+export const getCurrentBrandUsers = (queryClient, brandId) => {
+    const brandData = queryClient.getQueryData([QueryKeys.BRAND, brandId]);
+    return get(brandData, "users", []);
+};

package/build/react-query/hooks/folder-hooks.d.ts

@@ -0,0 +1,7 @@
+import { FolderEntity } from "../../utilities/constants/interface";
+import { QueryClient } from "react-query";
+export declare const updateFoldersCacheOnCreateFolder: (queryClient: QueryClient, id: string, folder: FolderEntity, key: string) => void;
+export declare const updateFoldersCacheOnDeleteFolder: (queryClient: QueryClient, id: string, folderId: string, key: string, dataKeyName?: string) => void;
+export declare const updateFoldersCacheOnUpdateFolder: (queryClient: QueryClient, id: string, newFolder: FolderEntity, key: string, dataKeyName?: string) => void;
+export declare const getFolderData: (queryClient: QueryClient, folderId: string, key: string) => any[];
+export declare const getSelectedFiles: (queryClient: QueryClient, folderId: string, key: string, fileIds: string[]) => any[];

package/build/react-query/hooks/folder-hooks.js

@@ -0,0 +1,119 @@
+import { DEFAULT_PAGE, DEFAULT_PAGE_SIZE } from "../../hocs/appConstants";
+import { cloneDeep, filter, findIndex, flatMap, get, includes, remove, set, } from "lodash";
+export const updateFoldersCacheOnCreateFolder = (queryClient, id, folder, key) => {
+    queryClient.setQueryData([key, id], (oldQueryData) => {
+        if (!oldQueryData) {
+            return {
+                pages: [
+                    {
+                        totalCount: DEFAULT_PAGE,
+                        totalPages: DEFAULT_PAGE,
+                        currentPage: DEFAULT_PAGE,
+                        size: DEFAULT_PAGE_SIZE,
+                        folders: [folder],
+                    },
+                ],
+                pageParams: [null],
+            };
+        }
+        const newQueryData = cloneDeep(oldQueryData);
+        const lastPage = newQueryData.pages[get(newQueryData, "pages.length") - 1];
+        if (get(lastPage, `folders.length`) < DEFAULT_PAGE_SIZE) {
+            get(lastPage, `folders`).push(folder);
+        }
+        else {
+            if (lastPage) {
+                newQueryData.pages.push({
+                    totalCount: get(lastPage, "totalCount", 0) + 1,
+                    totalPages: get(lastPage, "totalPages", 0) + 1,
+                    currentPage: get(lastPage, "currentPage", 0) + 1,
+                    size: DEFAULT_PAGE_SIZE,
+                    folders: [folder],
+                });
+            }
+            else {
+                newQueryData.pages = [
+                    {
+                        totalCount: 0,
+                        totalPages: DEFAULT_PAGE,
+                        currentPage: 1,
+                        size: DEFAULT_PAGE_SIZE,
+                        folders: [folder],
+                    },
+                ];
+            }
+        }
+        const totalCount = get(newQueryData, "pages[0].totalCount") + 1;
+        const totalPages = Math.ceil(totalCount / DEFAULT_PAGE_SIZE);
+        newQueryData.pages.forEach((page) => {
+            page.totalCount = totalCount;
+            page.totalPages = totalPages;
+            page.size = DEFAULT_PAGE_SIZE;
+        });
+        return newQueryData;
+    });
+};
+export const updateFoldersCacheOnDeleteFolder = (queryClient, id, folderId, key, dataKeyName = "folders") => {
+    queryClient.setQueryData([key, id], (oldQueryData) => {
+        if (!oldQueryData || !get(oldQueryData, "pages")) {
+            return;
+        }
+        const newQueryData = cloneDeep(oldQueryData);
+        let itemRemoved = false;
+        for (let page of get(newQueryData, "pages")) {
+            const result = remove(get(page, `${dataKeyName}`), (folder) => get(folder, "_id") === folderId);
+            if (get(result, "length") > 0) {
+                itemRemoved = true;
+            }
+        }
+        if (itemRemoved) {
+            const allItems = get(newQueryData, "pages").flatMap((page) => get(page, `${dataKeyName}`));
+            const totalCount = get(allItems, "length");
+            const totalPages = Math.ceil(totalCount / DEFAULT_PAGE_SIZE);
+            newQueryData.pages = [];
+            for (let i = 0; i < totalPages; i++) {
+                const startIdx = i * DEFAULT_PAGE_SIZE;
+                const pageItems = allItems.slice(startIdx, startIdx + DEFAULT_PAGE_SIZE);
+                newQueryData.pages.push({
+                    totalCount,
+                    totalPages,
+                    currentPage: i + 1,
+                    size: DEFAULT_PAGE_SIZE,
+                    [dataKeyName]: pageItems,
+                });
+            }
+        }
+        return newQueryData;
+    });
+};
+export const updateFoldersCacheOnUpdateFolder = (queryClient, id, newFolder, key, dataKeyName = "folders") => {
+    queryClient.setQueryData([key, id], (oldQueryData) => {
+        if (!oldQueryData || !get(oldQueryData, "pages")) {
+            return;
+        }
+        const newQueryData = cloneDeep(oldQueryData);
+        let itemUpdated = false;
+        newQueryData.pages.forEach((page) => {
+            const folders = get(page, dataKeyName);
+            const itemIndex = findIndex(folders, (folder) => get(folder, "_id") === get(newFolder, "_id"));
+            if (itemIndex > -1) {
+                set(folders, `[${itemIndex}]`, newFolder);
+                itemUpdated = true;
+            }
+        });
+        return newQueryData;
+    });
+};
+export const getFolderData = (queryClient, folderId, key) => {
+    const foldersPaginatedData = queryClient.getQueryData([key, folderId]);
+    return !!foldersPaginatedData
+        ? flatMap(get(foldersPaginatedData, "pages"), "folders")
+        : [];
+};
+export const getSelectedFiles = (queryClient, folderId, key, fileIds) => {
+    const foldersPaginatedData = queryClient.getQueryData([key, folderId]);
+    const files = !!foldersPaginatedData
+        ? flatMap(get(foldersPaginatedData, "pages"), "folders")
+        : [];
+    return filter(files, (file) => includes(fileIds, get(file, "_id")));
+};

package/build/react-query/services/brand-services.d.ts

@@ -0,0 +1,3 @@
+export declare function useCurrentBrand(headers: {
+    headers: any;
+}, brandId: string, enabled: boolean): import("react-query").UseQueryResult<any, unknown>;

package/build/react-query/services/brand-services.js

@@ -0,0 +1,30 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { FETCH_BRAND_URL } from "../../utilities/constants/apiUrls";
+import { QueryKeys } from "../../utilities/constants/queryKeys";
+import { get } from "lodash";
+import { useQuery } from "react-query";
+function fetchBrand(api, brandId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const response = yield api.get(FETCH_BRAND_URL.replace(":brandId", brandId));
+            return get(response, "data");
+        }
+        catch (error) {
+            throw error;
+        }
+    });
+}
+export function useCurrentBrand(headers, brandId, enabled) {
+    return useQuery([QueryKeys.BRAND, brandId], () => fetchBrand(headers, brandId), {
+        enabled: enabled && !!get(headers, "headers.Authorization"),
+        refetchOnWindowFocus: false,
+    });
+}

package/build/react-query/services/file-services.d.ts

@@ -0,0 +1,43 @@
+export declare const deleteFiles: ({ fileIds, folderIds, api, }: {
+    fileIds: string[];
+    folderIds: string[];
+    api: any;
+}) => Promise<any>;
+export declare const archiveFiles: ({ fileIds, folderIds, api, }: {
+    fileIds: string[];
+    folderIds: string[];
+    api: any;
+}) => Promise<any>;
+export declare const unarchiveFiles: ({ fileIds, folderIds, api, }: {
+    fileIds: string[];
+    folderIds: string[];
+    api: any;
+}) => Promise<any>;
+export declare const restoreFiles: ({ fileIds, folderIds, api, }: {
+    fileIds: string[];
+    folderIds: string[];
+    api: any;
+}) => Promise<any>;
+export declare const downloadFiles: ({ fileIds, folderIds, api, }: {
+    fileIds: string[];
+    folderIds: string[];
+    api: any;
+}) => Promise<any>;
+export declare const duplicateFiles: ({ fileIds, api, }: {
+    fileIds: string[];
+    api: any;
+}) => Promise<any>;
+export declare const moveFiles: ({ payload, api, }: {
+    payload: {
+        fileIds: string[];
+        destinationFolderId: string;
+        folderIds: string[];
+    };
+    api: any;
+}) => Promise<any>;
+export declare const useFile: (api: any, fileId?: string) => import("react-query").UseQueryResult<any, unknown>;
+export declare const updateFile: ({ fileId, payload, api, }: {
+    fileId: string;
+    payload: any;
+    api: any;
+}) => Promise<any>;

package/build/react-query/services/file-services.js

@@ -0,0 +1,69 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { addQueryParams } from "../../hocs/helpers";
+import { ARCHIVE_FILES_URL, CREATE_FILE_URL, DOWNLOAD_FILES_URL, DUPLICATE_FILE_URL, FETCH_FILE_URL, MOVE_FILES_URL, RESTORE_FILES_URL, UNARCHIVE_FILES_URL, } from "../../utilities/constants/apiUrls";
+import { QueryKeys } from "../../utilities/constants/queryKeys";
+import { get, join } from "lodash";
+import { useQuery } from "react-query";
+//delete files
+export const deleteFiles = (_a) => __awaiter(void 0, [_a], void 0, function* ({ fileIds, folderIds, api, }) {
+    return yield api.delete(`${CREATE_FILE_URL}?${addQueryParams({
+        fileIds: join(fileIds, ","),
+        folderIds: join(folderIds, ","),
+    })}`);
+});
+//archive files
+export const archiveFiles = (_a) => __awaiter(void 0, [_a], void 0, function* ({ fileIds, folderIds, api, }) {
+    return yield api.put(`${ARCHIVE_FILES_URL}`, { fileIds, folderIds });
+});
+//unarchive files
+export const unarchiveFiles = (_a) => __awaiter(void 0, [_a], void 0, function* ({ fileIds, folderIds, api, }) {
+    return yield api.put(UNARCHIVE_FILES_URL, { fileIds, folderIds });
+});
+//restore files
+export const restoreFiles = (_a) => __awaiter(void 0, [_a], void 0, function* ({ fileIds, folderIds, api, }) {
+    return yield api.put(RESTORE_FILES_URL, { fileIds, folderIds });
+});
+//download files
+export const downloadFiles = (_a) => __awaiter(void 0, [_a], void 0, function* ({ fileIds, folderIds, api, }) {
+    return yield api.post(`${DOWNLOAD_FILES_URL}`, { fileIds, folderIds });
+});
+//duplicate files
+export const duplicateFiles = (_a) => __awaiter(void 0, [_a], void 0, function* ({ fileIds, api, }) {
+    return yield api.put(DUPLICATE_FILE_URL, { fileIds });
+});
+//move files
+export const moveFiles = (_a) => __awaiter(void 0, [_a], void 0, function* ({ payload, api, }) {
+    return yield api.put(MOVE_FILES_URL, payload);
+});
+function fetchFile(api, fileId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const response = yield api.get(FETCH_FILE_URL.replace(":fileId", fileId));
+            return get(response, "data");
+        }
+        catch (error) {
+            throw error;
+        }
+    });
+}
+export const useFile = (api, fileId) => {
+    const isEnabled = !!fileId;
+    return useQuery({
+        queryKey: [QueryKeys.FILE, fileId],
+        queryFn: isEnabled ? () => fetchFile(api, fileId) : undefined,
+        enabled: isEnabled,
+        refetchOnWindowFocus: false,
+    });
+};
+//update file
+export const updateFile = (_a) => __awaiter(void 0, [_a], void 0, function* ({ fileId, payload, api, }) {
+    return yield api.put(FETCH_FILE_URL.replace(":fileId", fileId), payload);
+});

package/build/react-query/services/folder-services.d.ts

@@ -0,0 +1,44 @@
+import { DriveModes } from "../../utilities/constants/interface";
+import { QueryKeys } from "../../utilities/constants/queryKeys";
+export declare const useFolders: (api: any, queryKey: QueryKeys, params: {
+    page?: number;
+    category?: DriveModes;
+    includeSubFoldersCount?: boolean;
+    includeFiles?: boolean;
+    fetchMainFolders?: boolean;
+    isPagination?: boolean;
+}, folderId: string) => import("react-query").UseInfiniteQueryResult<any, unknown>;
+export declare const deleteFolders: ({ folderIds, api, }: {
+    folderIds: string[];
+    api: any;
+}) => Promise<any>;
+export declare const archiveFolders: ({ folderIds, api, }: {
+    folderIds: string[];
+    api: any;
+}) => Promise<any>;
+export declare const duplicateFolder: ({ folderId, api, }: {
+    folderId: string;
+    api: any;
+}) => Promise<any>;
+export declare const restoreFolders: ({ folderIds, api, }: {
+    folderIds: string[];
+    api: any;
+}) => Promise<any>;
+export declare const unarchiveFolders: ({ folderIds, api, }: {
+    folderIds: string[];
+    api: any;
+}) => Promise<any>;
+export declare const addToFavFolders: ({ payload, api, }: {
+    payload: {
+        fileIds: string[];
+        folderIds: string[];
+    };
+    api: any;
+}) => Promise<any>;
+export declare const removeFromFavFolders: ({ payload, api, }: {
+    payload: {
+        folderIds: string[];
+        fileIds: string[];
+    };
+    api: any;
+}) => Promise<any>;

package/build/react-query/services/folder-services.js

@@ -0,0 +1,87 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { DEFAULT_PAGE } from "../../hocs/appConstants";
+import { addQueryParams } from "../../hocs/helpers";
+import { ARCHIVE_FOLDERS_URL, DELETE_FOLDERS_URL, DUPLICATE_FOLDER_URL, FETCH_FOLDER_URL, FETCH_RECENT_FOLDERS_URL, FETCH_SHARED_FOLDERS_URL, FETCH_STARRED_FOLDERS_URL, FETCH_TRASH_FOLDERS_URL, RESTORE_TRASHED_FOLDERS_URL, UNARCHIVE_FOLDERS_URL, VIEW_SHARED_FOLDER_URL, } from "../../utilities/constants/apiUrls";
+import { DriveModes } from "../../utilities/constants/interface";
+import { get, includes, join } from "lodash";
+import { useInfiniteQuery } from "react-query";
+function fetchFolders(api, params, folderId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const response = yield api.get(`${get(params, "category") === DriveModes.STARRED
+                ? FETCH_STARRED_FOLDERS_URL
+                : get(params, "category") === DriveModes.RECENTS
+                    ? FETCH_RECENT_FOLDERS_URL
+                    : includes([DriveModes.ARCHIVES, DriveModes.TRASH], get(params, "category"))
+                        ? FETCH_TRASH_FOLDERS_URL
+                        : get(params, "category") === DriveModes.SHARED
+                            ? FETCH_SHARED_FOLDERS_URL
+                            : get(params, "category") === DriveModes.FOLDERS
+                                ? VIEW_SHARED_FOLDER_URL.replace(":folderId", folderId)
+                                : FETCH_FOLDER_URL.replace(":folderId", folderId)}?${addQueryParams(params)}`);
+            return get(response, "data");
+        }
+        catch (error) {
+            throw error;
+        }
+    });
+}
+export const useFolders = (api, queryKey, params, folderId) => {
+    return useInfiniteQuery({
+        queryKey: [queryKey, folderId],
+        queryFn: (_a) => __awaiter(void 0, [_a], void 0, function* ({ pageParam = DEFAULT_PAGE }) {
+            const updatedParams = Object.assign(Object.assign({}, params), { page: pageParam });
+            return fetchFolders(api, updatedParams, folderId);
+        }),
+        getNextPageParam: (lastPage, allPages) => {
+            const currentPage = Number(get(lastPage, "currentPage"));
+            const totalPages = get(lastPage, "totalPages");
+            if (currentPage < totalPages) {
+                return currentPage + 1;
+            }
+            else {
+                return undefined;
+            }
+        },
+        enabled: folderId ? true : false,
+        refetchOnWindowFocus: false,
+    });
+};
+//delete folder
+export const deleteFolders = (_a) => __awaiter(void 0, [_a], void 0, function* ({ folderIds, api, }) {
+    return yield api.delete(`${DELETE_FOLDERS_URL}?${addQueryParams({
+        folderIds: join(folderIds, ","),
+    })}`);
+});
+//archive folder
+export const archiveFolders = (_a) => __awaiter(void 0, [_a], void 0, function* ({ folderIds, api, }) {
+    return yield api.put(`${ARCHIVE_FOLDERS_URL}`, { folderIds });
+});
+//duplicate folder
+export const duplicateFolder = (_a) => __awaiter(void 0, [_a], void 0, function* ({ folderId, api, }) {
+    return yield api.put(DUPLICATE_FOLDER_URL.replace(":folderId", folderId), {});
+});
+//restore folders
+export const restoreFolders = (_a) => __awaiter(void 0, [_a], void 0, function* ({ folderIds, api, }) {
+    return yield api.put(RESTORE_TRASHED_FOLDERS_URL, { folderIds });
+});
+//unarchive folders
+export const unarchiveFolders = (_a) => __awaiter(void 0, [_a], void 0, function* ({ folderIds, api, }) {
+    return yield api.put(UNARCHIVE_FOLDERS_URL, { folderIds });
+});
+//star the folder
+export const addToFavFolders = (_a) => __awaiter(void 0, [_a], void 0, function* ({ payload, api, }) {
+    return yield api.post(FETCH_STARRED_FOLDERS_URL, payload);
+});
+//unstar the folder
+export const removeFromFavFolders = (_a) => __awaiter(void 0, [_a], void 0, function* ({ payload, api, }) {
+    return yield api.put(FETCH_STARRED_FOLDERS_URL, payload);
+});

package/build/react-query/services/image-picker-services.d.ts

@@ -0,0 +1,5 @@
+export declare const useImagePickers: (headers: {
+    headers: any;
+}, params: {
+    page?: number;
+}, id: string) => import("react-query").UseInfiniteQueryResult<any, unknown>;