@soppiya/app-bridge 1.0.0

package/dist/components/media/MediaPreview.js

@@ -0,0 +1,127 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import docs from "../../assets/images/docs.js";
+import pdf from "../../assets/images/pdf.js";
+import ppt from "../../assets/images/ppt.js";
+import rar from "../../assets/images/rar.js";
+import txt from "../../assets/images/txt.js";
+import xls from "../../assets/images/xls.js";
+import zip from "../../assets/images/zip.js";
+import { BlockStack, Box, Button, InlineStack, SoppiyaIcon, Text } from "@soppiya/elementus";
+import { formatToBytes } from "./format.js";
+const MediaPreview_MediaPreview = ({ media, onClose })=>{
+    const getFileImg = ()=>{
+        if (media?.mimetype?.includes("pdf")) return pdf;
+        if (media?.mimetype?.includes("vnd.openxmlformats-officedocument.spreadsheetml.sheet") || media?.mimetype?.includes("vnd.ms-excel")) return xls;
+        if (media?.mimetype?.includes("x-zip-compressed")) return zip;
+        if (media?.mimetype?.includes("x-compressed")) return rar;
+        if (media?.mimetype?.includes("text/plain") || media?.mimetype?.includes("rtf")) return txt;
+        else if (media?.mimetype?.includes("vnd.openxmlformats-officedocument.presentationml.presentation") || media?.mimetype?.includes("vnd.ms-powerpoint")) return ppt;
+        else if (media?.mimetype?.includes("vnd.openxmlformats-officedocument.wordprocessingml.document") || media?.mimetype?.includes("msword")) return docs;
+    };
+    let mediaSrc = null;
+    switch(media?.type){
+        case "image":
+            mediaSrc = /*#__PURE__*/ jsx(Box, {
+                className: "h-full",
+                children: /*#__PURE__*/ jsx("img", {
+                    src: String(media?.url),
+                    className: "object-contain !h-full"
+                })
+            });
+            break;
+        case "audio":
+            mediaSrc = /*#__PURE__*/ jsx(Box, {
+                className: "w-full",
+                children: /*#__PURE__*/ jsx("audio", {
+                    controls: true,
+                    src: String(media?.url),
+                    className: "w-full"
+                })
+            });
+            break;
+        case "video":
+            mediaSrc = /*#__PURE__*/ jsx(Box, {
+                className: "w-full",
+                children: /*#__PURE__*/ jsx("video", {
+                    controls: true,
+                    src: String(media?.url),
+                    className: "object-contain max-h-[300px] w-full mx-auto"
+                })
+            });
+            break;
+        case "file":
+            mediaSrc = /*#__PURE__*/ jsx(Box, {
+                className: "w-full flex justify-center",
+                children: /*#__PURE__*/ jsx("img", {
+                    src: getFileImg(),
+                    alt: "file icon",
+                    className: "w-[100px] h-[100px] object-contain"
+                })
+            });
+            break;
+        default:
+            /*#__PURE__*/ String(media?.url);
+    }
+    return /*#__PURE__*/ jsxs(BlockStack, {
+        padding: {
+            px: 80,
+            py: 60
+        },
+        gapY: 60,
+        justifyContent: "space-between",
+        className: "!bg-[#f7f7f7] h-[calc(100%-80px)] z-30 top-[80px] md:top-0 md:h-auto visible  left-0 !absolute md:!relative !w-full md:!w-[273px] lg:!w-[336px]",
+        children: [
+            /*#__PURE__*/ jsxs(InlineStack, {
+                alignItems: "center",
+                justifyContent: "space-between",
+                children: [
+                    /*#__PURE__*/ jsx(Box, {
+                        children: /*#__PURE__*/ jsx(Text, {
+                            size: "md",
+                            weight: "semibold",
+                            children: "Preview"
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(Box, {
+                        children: /*#__PURE__*/ jsx(Button, {
+                            variant: "plain",
+                            onClick: ()=>onClose(),
+                            children: /*#__PURE__*/ jsx(SoppiyaIcon, {
+                                icon: "cross.svg",
+                                size: "sm"
+                            })
+                        })
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsx(InlineStack, {
+                alignItems: "center",
+                justifyContent: "center",
+                gapX: 80,
+                className: "h-[calc(100%-80px)]",
+                children: mediaSrc
+            }),
+            /*#__PURE__*/ jsxs(BlockStack, {
+                children: [
+                    /*#__PURE__*/ jsxs(Text, {
+                        size: "sm",
+                        weight: "medium",
+                        color: "info",
+                        children: [
+                            "\u2022",
+                            formatToBytes(Number(media?.size), 2)
+                        ]
+                    }),
+                    /*#__PURE__*/ jsx(Text, {
+                        size: "sm",
+                        weight: "medium",
+                        color: "secondary",
+                        children: media?.file_name
+                    })
+                ]
+            })
+        ]
+    });
+};
+const MediaPreview = MediaPreview_MediaPreview;
+export { MediaPreview as default };

package/dist/components/media/MediaSorting.d.ts

@@ -0,0 +1,8 @@
+import { InputMaybe, MediaSortKeys } from "../../shared/graphql/graphql";
+import { MediaSort } from "./types";
+type MediaSortingProps = {
+    sort: MediaSort;
+    onChange: (sortKey: InputMaybe<MediaSortKeys>, reverse: boolean) => void;
+};
+declare const MediaSorting: ({ sort, onChange }: MediaSortingProps) => import("react/jsx-runtime").JSX.Element;
+export default MediaSorting;

package/dist/components/media/MediaSorting.js

@@ -0,0 +1,85 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { MediaSortKeys } from "../../shared/graphql/graphql.js";
+import { Box, Button, Card, Listbox, Radio, SoppiyaIcon } from "@soppiya/elementus";
+import { useClickAway } from "@uidotdev/usehooks";
+import { useState } from "react";
+const MediaSorting = ({ sort, onChange })=>{
+    const [open, setOpen] = useState(false);
+    const ref = useClickAway(()=>setOpen(false));
+    const toggleOpen = ()=>{
+        setOpen(!open);
+    };
+    return /*#__PURE__*/ jsxs(Box, {
+        ref: ref,
+        className: "relative",
+        children: [
+            /*#__PURE__*/ jsx(Button, {
+                variant: "outline",
+                color: "secondary",
+                className: "!px-[8px]",
+                onClick: toggleOpen,
+                children: /*#__PURE__*/ jsx(SoppiyaIcon, {
+                    size: "sm",
+                    icon: "filter-01.svg"
+                })
+            }),
+            open && /*#__PURE__*/ jsx(Card, {
+                className: "absolute !w-[150px] z-1 right-0 top-9 overflow-hidden",
+                children: /*#__PURE__*/ jsxs(Listbox, {
+                    children: [
+                        /*#__PURE__*/ jsx(Listbox.Option, {
+                            children: /*#__PURE__*/ jsx(Radio, {
+                                label: "Date (new - old)",
+                                labelPosition: "center",
+                                checked: sort.sortKey === MediaSortKeys.createdAt && sort.reverse,
+                                onChange: ()=>onChange(MediaSortKeys.createdAt, true)
+                            })
+                        }),
+                        /*#__PURE__*/ jsx(Listbox.Option, {
+                            children: /*#__PURE__*/ jsx(Radio, {
+                                label: "Date (old - new)",
+                                labelPosition: "center",
+                                checked: sort.sortKey === MediaSortKeys.createdAt && !sort.reverse,
+                                onChange: ()=>onChange(MediaSortKeys.createdAt, false)
+                            })
+                        }),
+                        /*#__PURE__*/ jsx(Listbox.Option, {
+                            children: /*#__PURE__*/ jsx(Radio, {
+                                label: "File name (A - Z)",
+                                labelPosition: "center",
+                                checked: sort.sortKey === MediaSortKeys.file_name && !sort.reverse,
+                                onChange: ()=>onChange(MediaSortKeys.file_name, false)
+                            })
+                        }),
+                        /*#__PURE__*/ jsx(Listbox.Option, {
+                            children: /*#__PURE__*/ jsx(Radio, {
+                                label: "File name (Z - A)",
+                                labelPosition: "center",
+                                checked: sort.sortKey === MediaSortKeys.file_name && sort.reverse,
+                                onChange: ()=>onChange(MediaSortKeys.file_name, true)
+                            })
+                        }),
+                        /*#__PURE__*/ jsx(Listbox.Option, {
+                            children: /*#__PURE__*/ jsx(Radio, {
+                                label: "Type (A - Z)",
+                                labelPosition: "center",
+                                checked: sort.sortKey === MediaSortKeys.type && !sort.reverse,
+                                onChange: ()=>onChange(MediaSortKeys.type, false)
+                            })
+                        }),
+                        /*#__PURE__*/ jsx(Listbox.Option, {
+                            children: /*#__PURE__*/ jsx(Radio, {
+                                label: "Type (Z - A)",
+                                labelPosition: "center",
+                                checked: sort.sortKey === MediaSortKeys.type && sort.reverse,
+                                onChange: ()=>onChange(MediaSortKeys.type, true)
+                            })
+                        })
+                    ]
+                })
+            })
+        ]
+    });
+};
+const media_MediaSorting = MediaSorting;
+export { media_MediaSorting as default };

package/dist/components/media/format.d.ts

@@ -0,0 +1 @@
+export declare const formatToBytes: (bytes: number, decimals?: number) => string;

package/dist/components/media/format.js

@@ -0,0 +1,28 @@
+const formatToBytes = (bytes, decimals = 2)=>{
+    if (!bytes) return "0 Bytes";
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = [
+        "Bytes",
+        "KB",
+        "MB",
+        "GB",
+        "TB",
+        "PB",
+        "EB",
+        "ZB",
+        "YB"
+    ];
+    const thresholdGB = 500 * Math.pow(k, 2);
+    let i;
+    let value;
+    if (bytes >= thresholdGB) {
+        i = 3;
+        value = bytes / Math.pow(k, 3);
+    } else {
+        i = Math.floor(Math.log(bytes) / Math.log(k));
+        value = bytes / Math.pow(k, i);
+    }
+    return `${parseFloat(value.toFixed(dm))} ${sizes[i]}`;
+};
+export { formatToBytes };

package/dist/components/media/graph.d.ts

@@ -0,0 +1,22 @@
+export declare const mediasQuery: import("@graphql-typed-document-node/core").TypedDocumentNode<import("../../shared/graphql/graphql").MediasQuery, import("../../shared/graphql/graphql").Exact<{
+    after?: import("../../shared/graphql/graphql").InputMaybe<import("../../shared/graphql/graphql").Scalars["ID"]["input"]>;
+    before?: import("../../shared/graphql/graphql").InputMaybe<import("../../shared/graphql/graphql").Scalars["ID"]["input"]>;
+    first?: import("../../shared/graphql/graphql").InputMaybe<import("../../shared/graphql/graphql").Scalars["Int"]["input"]>;
+    last?: import("../../shared/graphql/graphql").InputMaybe<import("../../shared/graphql/graphql").Scalars["Int"]["input"]>;
+    query?: import("../../shared/graphql/graphql").InputMaybe<import("../../shared/graphql/graphql").Scalars["String"]["input"]>;
+    reverse?: import("../../shared/graphql/graphql").InputMaybe<import("../../shared/graphql/graphql").Scalars["Boolean"]["input"]>;
+    sortKey?: import("../../shared/graphql/graphql").InputMaybe<import("../../shared/graphql/graphql").MediaSortKeys>;
+    filterKeys?: import("../../shared/graphql/graphql").InputMaybe<import("../../shared/graphql/graphql").MediaFilterKeys>;
+}>>;
+export declare const storagePlanQuery: import("@graphql-typed-document-node/core").TypedDocumentNode<import("../../shared/graphql/graphql").StoragePlanQuery, import("../../shared/graphql/graphql").Exact<{
+    [key: string]: never;
+}>>;
+export declare const mediaUsagesQuery: import("@graphql-typed-document-node/core").TypedDocumentNode<import("../../shared/graphql/graphql").MediaUsageQuery, import("../../shared/graphql/graphql").Exact<{
+    [key: string]: never;
+}>>;
+export declare const addMediasMutation: import("@graphql-typed-document-node/core").TypedDocumentNode<import("../../shared/graphql/graphql").AddMediasMutation, import("../../shared/graphql/graphql").Exact<{
+    input: Array<import("../../shared/graphql/graphql").Scalars["Upload"]["input"]> | import("../../shared/graphql/graphql").Scalars["Upload"]["input"];
+}>>;
+export declare const deleteMediasMutation: import("@graphql-typed-document-node/core").TypedDocumentNode<import("../../shared/graphql/graphql").DeleteMediasMutation, import("../../shared/graphql/graphql").Exact<{
+    cursors: Array<import("../../shared/graphql/graphql").Scalars["ID"]["input"]> | import("../../shared/graphql/graphql").Scalars["ID"]["input"];
+}>>;

package/dist/components/media/graph.js

@@ -0,0 +1,75 @@
+import { graphql } from "../../shared/graphql/index.js";
+const mediasQuery = graphql(`
+  query Medias(
+    $after: ID
+    $before: ID
+    $first: Int
+    $last: Int
+    $query: String
+    $reverse: Boolean
+    $sortKey: MediaSortKeys
+    $filterKeys: MediaFilterKeys
+  ) {
+    medias(
+      after: $after
+      before: $before
+      first: $first
+      last: $last
+      query: $query
+      reverse: $reverse
+      sortKey: $sortKey
+      filterKeys: $filterKeys
+    ) {
+      edges {
+        node {
+          _id
+          file_name
+          url
+          size
+          type
+          mimetype
+        }
+      }
+      pageInfo {
+        endCursor
+        hasNextPage
+        hasPreviousPage
+        startCursor
+      }
+    }
+  }
+`);
+const storagePlanQuery = graphql(`
+  query StoragePlan {
+    plan {
+      storage
+      package {
+        _id
+        storage
+      }
+    }
+  }
+`);
+const mediaUsagesQuery = graphql(`
+  query MediaUsage {
+    mediaUsage
+  }
+`);
+const addMediasMutation = graphql(`
+  mutation AddMedias($input: [Upload!]!) {
+    addMedias(input: $input) {
+      _id
+      file_name
+      url
+      size
+    }
+  }
+`);
+const deleteMediasMutation = graphql(`
+  mutation DeleteMedias($cursors: [ID!]!) {
+    deleteMedias(cursors: $cursors) {
+      message
+    }
+  }
+`);
+export { addMediasMutation, deleteMediasMutation, mediaUsagesQuery, mediasQuery, storagePlanQuery };

package/dist/components/media/index.d.ts

@@ -0,0 +1 @@
+export { default as Media } from "./Media";

package/dist/components/media/index.js

@@ -0,0 +1,2 @@
+import Media from "./Media.js";
+export { Media };

package/dist/components/media/types.d.ts

@@ -0,0 +1,13 @@
+import { InputMaybe, MediaSortKeys } from "../../shared/graphql/graphql";
+export declare enum View {
+    List = "LIST",
+    Grid = "GRID"
+}
+export type UploadFile = {
+    url: string;
+    file: File;
+};
+export type MediaSort = {
+    sortKey: InputMaybe<MediaSortKeys>;
+    reverse: boolean;
+};

package/dist/components/media/types.js

@@ -0,0 +1,6 @@
+var types_View = /*#__PURE__*/ function(View) {
+    View["List"] = "LIST";
+    View["Grid"] = "GRID";
+    return View;
+}({});
+export { types_View as View };

package/dist/components/media/uploadMedias.d.ts

@@ -0,0 +1,7 @@
+import { useMutation } from "@apollo/client/react";
+export declare const useUploadMedias: () => {
+    uploadMedias: useMutation.MutationFunction<import("../../shared/graphql/graphql").AddMediasMutation, {
+        input: Array<import("../../shared/graphql/graphql").Scalars["Upload"]["input"]> | import("../../shared/graphql/graphql").Scalars["Upload"]["input"];
+    }, import("@apollo/client").ApolloCache>;
+    isUploadingMedias: boolean;
+};

package/dist/components/media/uploadMedias.js

@@ -0,0 +1,31 @@
+import { useMutation } from "@apollo/client/react";
+import { addMediasMutation } from "./graph.js";
+const useUploadMedias = ()=>{
+    const [uploadMedias, { loading: isUploadingMedias }] = useMutation(addMediasMutation, {
+        update (cache, { data }) {
+            cache.modify({
+                fields: {
+                    medias (existing) {
+                        const newEdges = data?.addMedias?.map((media)=>({
+                                __typename: "MediaEdge",
+                                node: media,
+                                cursor: media?._id
+                            }));
+                        return {
+                            ...existing,
+                            edges: [
+                                ...newEdges ?? [],
+                                ...existing.edges
+                            ]
+                        };
+                    }
+                }
+            });
+        }
+    });
+    return {
+        uploadMedias,
+        isUploadingMedias
+    };
+};
+export { useUploadMedias };

package/dist/components/media/useDeleteMedias.d.ts

@@ -0,0 +1,7 @@
+import { useMutation } from "@apollo/client/react";
+export declare const useDeleteMedias: () => {
+    deleteMedias: useMutation.MutationFunction<import("../../shared/graphql/graphql").DeleteMediasMutation, {
+        cursors: Array<import("../../shared/graphql/graphql").Scalars["ID"]["input"]> | import("../../shared/graphql/graphql").Scalars["ID"]["input"];
+    }, import("@apollo/client").ApolloCache>;
+    isDeletingMedias: boolean;
+};

package/dist/components/media/useDeleteMedias.js

@@ -0,0 +1,14 @@
+import { useMutation } from "@apollo/client/react";
+import { deleteMediasMutation } from "./graph.js";
+const useDeleteMedias = ()=>{
+    const [deleteMedias, { loading: isDeletingMedias }] = useMutation(deleteMediasMutation, {
+        refetchQueries: [
+            "Medias"
+        ]
+    });
+    return {
+        deleteMedias,
+        isDeletingMedias
+    };
+};
+export { useDeleteMedias };

package/dist/components/media/useDrop.d.ts

@@ -0,0 +1,11 @@
+import { UploadFile } from "./types";
+type UseDropProps = {
+    onComplete?: (files: UploadFile[]) => void;
+};
+export declare const useDrop: ({ onComplete }?: UseDropProps) => {
+    ref: import("react").RefObject<HTMLInputElement | null>;
+    onDrop: (event: React.DragEvent<HTMLDivElement>) => Promise<void>;
+    onDragOver: (event: React.DragEvent<HTMLDivElement>) => void;
+    onChangeFile: (event: React.ChangeEvent<HTMLInputElement>) => Promise<void>;
+};
+export {};

package/dist/components/media/useDrop.js

@@ -0,0 +1,41 @@
+import { useRef } from "react";
+const useDrop = ({ onComplete } = {})=>{
+    const ref = useRef(null);
+    const fileProcessing = (file)=>{
+        if (!file) return;
+        return new Promise((resolve, reject)=>{
+            const reader = new FileReader();
+            reader.onload = (event)=>{
+                const result = event.target?.result;
+                if ("string" == typeof result) resolve({
+                    url: result,
+                    file
+                });
+                else reject(new Error("FileReader result is not a string"));
+            };
+            reader.readAsDataURL(file);
+        });
+    };
+    const getProcessedFiles = async (files)=>Promise.all(files.map((file)=>fileProcessing(file)).filter((file)=>void 0 !== file));
+    const onDrop = async (event)=>{
+        event.preventDefault();
+        const files = Array.from(event.dataTransfer.files);
+        const results = await getProcessedFiles(files);
+        onComplete?.(results);
+    };
+    const onDragOver = (event)=>{
+        event.preventDefault();
+    };
+    const onChangeFile = async (event)=>{
+        const files = Array.from(event.target.files ?? []);
+        const results = await getProcessedFiles(files);
+        onComplete?.(results);
+    };
+    return {
+        ref,
+        onDrop,
+        onDragOver,
+        onChangeFile
+    };
+};
+export { useDrop };

package/dist/components/media/useMediaFilter.d.ts

@@ -0,0 +1,5 @@
+export declare const useMediaFilter: () => {
+    query: string;
+    debounceQuery: string;
+    onChangeQuery: (value: string) => void;
+};

package/dist/components/media/useMediaFilter.js

@@ -0,0 +1,15 @@
+import { useDebounce } from "@uidotdev/usehooks";
+import { useState } from "react";
+const useMediaFilter = ()=>{
+    const [query, setQuery] = useState("");
+    const debounceQuery = useDebounce(query, 300);
+    const onChangeQuery = (value)=>{
+        setQuery(value);
+    };
+    return {
+        query,
+        debounceQuery,
+        onChangeQuery
+    };
+};
+export { useMediaFilter };

package/dist/components/media/useMediaSorting.d.ts

@@ -0,0 +1,6 @@
+import { InputMaybe, MediaSortKeys } from "../../shared/graphql/graphql";
+import { MediaSort } from "./types";
+export declare const useMediaSorting: () => {
+    sorting: MediaSort;
+    onChangeSorting: (sortKey: InputMaybe<MediaSortKeys>, reverse: boolean) => void;
+};

package/dist/components/media/useMediaSorting.js

@@ -0,0 +1,19 @@
+import { MediaSortKeys } from "../../shared/graphql/graphql.js";
+import { useState } from "react";
+const useMediaSorting = ()=>{
+    const [sorting, setSorting] = useState({
+        sortKey: MediaSortKeys.createdAt,
+        reverse: true
+    });
+    const onChangeSorting = (sortKey, reverse)=>{
+        setSorting({
+            sortKey,
+            reverse
+        });
+    };
+    return {
+        sorting,
+        onChangeSorting
+    };
+};
+export { useMediaSorting };

package/dist/components/media/useMedias.d.ts

@@ -0,0 +1,31 @@
+import { InputMaybe, MediaFilterKeys, MediaSortKeys } from "../../shared/graphql/graphql";
+type UseMediasProps = {
+    count?: number;
+    query?: string;
+    reverse?: boolean;
+    sortKey?: InputMaybe<MediaSortKeys>;
+    filterKeys?: InputMaybe<MediaFilterKeys>;
+};
+export declare const useMedias: ({ count, query, reverse, sortKey, filterKeys }?: UseMediasProps) => {
+    medias: ({
+        __typename: "Media";
+        _id?: string | null;
+        file_name?: string | null;
+        url?: string | null;
+        size?: string | null;
+        type?: import("../../shared/graphql/graphql").MediaType | null;
+        mimetype?: string | null;
+    } | null | undefined)[];
+    pageInfo: {
+        __typename: "PageInfo";
+        endCursor?: string | null;
+        hasNextPage?: boolean | null;
+        hasPreviousPage?: boolean | null;
+        startCursor?: string | null;
+    } | null | undefined;
+    isLoadingMedias: boolean;
+    isFetchingMore: boolean;
+    error: import("@apollo/client").ErrorLike | undefined;
+    fetchMoreMedias: () => void;
+};
+export {};

package/dist/components/media/useMedias.js

@@ -0,0 +1,58 @@
+import { NetworkStatus } from "@apollo/client";
+import { useQuery } from "@apollo/client/react";
+import { useCallback, useRef } from "react";
+import { mediasQuery } from "./graph.js";
+const useMedias = ({ count = 20, query = "", reverse, sortKey, filterKeys } = {})=>{
+    const arrayRef = useRef([]);
+    const { data, loading: isLoadingMedias, error, networkStatus, fetchMore } = useQuery(mediasQuery, {
+        notifyOnNetworkStatusChange: true,
+        variables: {
+            first: count,
+            query,
+            reverse,
+            sortKey,
+            filterKeys
+        }
+    });
+    const medias = data?.medias?.edges?.map((edge)=>edge?.node) ?? arrayRef.current;
+    const isFetchingMore = networkStatus === NetworkStatus.fetchMore;
+    const pageInfo = data?.medias?.pageInfo;
+    const fetchMoreMedias = useCallback(()=>{
+        if (!pageInfo?.hasNextPage) return;
+        fetchMore({
+            variables: {
+                query,
+                reverse,
+                sortKey,
+                filterKeys,
+                first: count,
+                after: pageInfo.endCursor
+            },
+            updateQuery (prev, { fetchMoreResult }) {
+                if (!fetchMoreResult.medias?.edges || !prev.medias?.edges) return prev;
+                return {
+                    medias: {
+                        ...fetchMoreResult.medias,
+                        edges: [
+                            ...prev.medias.edges,
+                            ...fetchMoreResult.medias.edges
+                        ]
+                    }
+                };
+            }
+        });
+    }, [
+        fetchMore,
+        pageInfo,
+        count
+    ]);
+    return {
+        medias,
+        pageInfo,
+        isLoadingMedias,
+        isFetchingMore,
+        error,
+        fetchMoreMedias
+    };
+};
+export { useMedias };

package/dist/components/media/useStorage.d.ts

@@ -0,0 +1,8 @@
+export declare const useStorage: () => {
+    mediaUsage: number;
+    totalStorage: number;
+    usageStorage: number;
+    refetchMediaUsage: (variables?: Partial<import("../../shared/graphql/graphql").Exact<{
+        [key: string]: never;
+    }>> | undefined) => Promise<import("@apollo/client").ApolloClient.QueryResult<import("../../shared/graphql/graphql").MediaUsageQuery>>;
+};