@antscorp/antsomi-ui 1.3.3-beta.7 → 1.3.3-beta.70

package/es/components/molecules/ShareAccess/types.d.ts

@@ -0,0 +1,54 @@
+import { updateModalTransferOwnership, updateObjAccessInfo } from './actions';
+export type UserInfo = {
+    avatar: string;
+    full_name: string;
+    email: string;
+    user_id: number;
+    user_name: string;
+    user_type: number;
+    ctime: Date;
+    utime: Date;
+};
+export type UserAccessInfo = {
+    userId: number;
+    fullName: string;
+    email: string;
+    avatar: string;
+    role: number;
+    allowView: number;
+    allowEdit: number;
+    allowComment: number;
+    [key: string]: any;
+};
+export type ObjectAccessInfo = {
+    isPublic: number;
+    publicRole: number | null;
+    ownerId: number;
+    listAccess: UserAccessInfo[];
+};
+export type ShareAccessProps = {
+    userId?: number;
+    userPermission?: {
+        edit: number;
+        view: number;
+    };
+    accessInfo?: ObjectAccessInfo;
+    allowChangeOnwership?: boolean;
+    getUserInfo?(search: string, signal: AbortSignal): Promise<UserInfo[]> | UserInfo[];
+    onChange?: (accessInfo: ObjectAccessInfo) => void;
+};
+export type ShareAccessState = {
+    accessInfo?: ObjectAccessInfo;
+    accessUserId?: number;
+    accessUserPermission?: {
+        view: number;
+        edit: number;
+    };
+    modalTransferOwnership: {
+        open: boolean;
+        userToOwnerShipId: number;
+    };
+};
+export type ShareAccessAction = ReturnType<typeof updateObjAccessInfo> | ReturnType<typeof updateModalTransferOwnership>;
+export type AccessRole = 1 | 2 | 3;
+export type GeneralAccess = 1 | 0;

package/es/components/molecules/ShareAccess/types.js

@@ -0,0 +1 @@
+export {};

package/es/components/molecules/ShareAccess/utils.d.ts

@@ -0,0 +1,38 @@
+import { ObjectAccessInfo } from './types';
+export declare const mergePermission: (objectPermissionAllow: boolean, menuPermissionValue: number) => boolean;
+export declare const composeObjectMenuPermissions: (params: {
+    isPublic: boolean;
+    publicRole: number | null;
+    objectPermission: {
+        edit: boolean;
+        view: boolean;
+    };
+    menuPermission: {
+        edit: number;
+        view: number;
+    };
+}) => {
+    edit: boolean;
+    view: boolean;
+};
+export declare const getActionsByUser: (args: {
+    userId?: number;
+    userPermission?: {
+        view: number;
+        edit: number;
+    };
+    updatedUserId?: number;
+    objectAccessInfo?: ObjectAccessInfo;
+}) => ({
+    readonly label: "Viewer";
+    readonly key: "to_viewer";
+} | {
+    readonly label: "Editor";
+    readonly key: "to_editor";
+} | {
+    readonly label: "Transfer ownership";
+    readonly key: "to_owner";
+} | {
+    readonly label: "Remove Access";
+    readonly key: "remove_acess";
+})[];

package/es/components/molecules/ShareAccess/utils.js

@@ -0,0 +1,57 @@
+import { MENU_PERMISSION, PEOPLE_ACTIONS, PEOPLE_ACTION_KEYS, PUBLIC_ROLE, ROLE_MAPPING, } from './constants';
+import { remove } from 'lodash';
+export const mergePermission = (objectPermissionAllow, menuPermissionValue) => {
+    const valueMapping = {
+        [`${MENU_PERMISSION.NONE}_false`]: false,
+        [`${MENU_PERMISSION.CREATED_BY_USER}_false`]: false,
+        [`${MENU_PERMISSION.MANAGEMENT_BY_USER}_false`]: false,
+        [`${MENU_PERMISSION.EVERYTHING}_false`]: true,
+        [`${MENU_PERMISSION.NONE}_true`]: false,
+        [`${MENU_PERMISSION.CREATED_BY_USER}_true`]: true,
+        [`${MENU_PERMISSION.MANAGEMENT_BY_USER}_true`]: true,
+        [`${MENU_PERMISSION.EVERYTHING}_true`]: true,
+    };
+    return !!valueMapping[`${menuPermissionValue}_${objectPermissionAllow}`];
+};
+export const composeObjectMenuPermissions = (params) => {
+    const { menuPermission, objectPermission, isPublic, publicRole } = params;
+    const edit = mergePermission(objectPermission.edit, menuPermission.edit);
+    const view = mergePermission(objectPermission.view, menuPermission.view);
+    return {
+        edit: edit || (isPublic && publicRole === PUBLIC_ROLE.ONLY_EDITOR),
+        view: view || (isPublic && publicRole === PUBLIC_ROLE.ONLY_VIEWER),
+    };
+};
+export const getActionsByUser = (args) => {
+    const { userId, userPermission, updatedUserId, objectAccessInfo } = args;
+    if (!userId || !updatedUserId || !objectAccessInfo)
+        return [];
+    const { ownerId, listAccess, publicRole, isPublic } = objectAccessInfo;
+    const user = listAccess.find(access => access.userId === userId);
+    const updatedUser = listAccess.find(access => access.userId === updatedUserId);
+    const { edit: allowEdit } = composeObjectMenuPermissions({
+        isPublic: !!isPublic,
+        publicRole,
+        objectPermission: {
+            view: !!(user === null || user === void 0 ? void 0 : user.allowView),
+            edit: !!(user === null || user === void 0 ? void 0 : user.allowEdit),
+        },
+        menuPermission: {
+            view: (userPermission === null || userPermission === void 0 ? void 0 : userPermission.view) || MENU_PERMISSION.NONE,
+            edit: (userPermission === null || userPermission === void 0 ? void 0 : userPermission.edit) || MENU_PERMISSION.NONE,
+        },
+    });
+    if ((!user && !isPublic) || !updatedUser || !allowEdit || updatedUser.userId === ownerId)
+        return [];
+    const actions = Object.values(PEOPLE_ACTION_KEYS);
+    if (userId !== ownerId) {
+        remove(actions, actKey => actKey === PEOPLE_ACTION_KEYS.TO_OWNER);
+    }
+    if (allowEdit && updatedUser.role === ROLE_MAPPING.EDITOR) {
+        remove(actions, actKey => actKey === PEOPLE_ACTION_KEYS.TO_EDITOR);
+    }
+    if (allowEdit && updatedUser.role === ROLE_MAPPING.VIEWER) {
+        remove(actions, actKey => actKey === PEOPLE_ACTION_KEYS.TO_VIEWER);
+    }
+    return actions.map(actKey => PEOPLE_ACTIONS[actKey]);
+};

package/es/components/molecules/TreeSelect/TreeSelect.d.ts

@@ -1,12 +1,11 @@
 /// <reference types="react" />
-export declare const TreeSelect: (<ValueType = any, OptionType extends import("rc-tree-select/lib/TreeSelect").BaseOptionType | import("rc-tree-select/lib/TreeSelect").DefaultOptionType = import("rc-tree-select/lib/TreeSelect").DefaultOptionType>(props: import("antd").TreeSelectProps<ValueType, OptionType> & {
+export declare const TreeSelect: (<ValueType = any, OptionType extends import("rc-tree-select/lib/TreeSelect").DefaultOptionType | import("rc-tree-select/lib/TreeSelect").BaseOptionType = import("rc-tree-select/lib/TreeSelect").DefaultOptionType>(props: import("antd").TreeSelectProps<ValueType, OptionType> & {
     children?: import("react").ReactNode;
-} & {
-    ref?: import("react").Ref<import("antd").RefSelectProps> | undefined;
-}) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>) & {
+} & import("react").RefAttributes<import("antd").RefSelectProps>) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>) & {
+    displayName?: string | undefined;
     TreeNode: import("react").FC<import("rc-tree-select/lib/TreeNode").TreeNodeProps>;
     SHOW_ALL: "SHOW_ALL";
     SHOW_PARENT: "SHOW_PARENT";
     SHOW_CHILD: "SHOW_CHILD";
-    _InternalPanelDoNotUseOrYouWillBeFired: any;
+    _InternalPanelDoNotUseOrYouWillBeFired: (props: import("antd/es/_util/type").AnyObject) => import("react").JSX.Element;
 };

package/es/components/molecules/UploadImage/MediaIcon.d.ts

@@ -1,2 +1,3 @@
-declare const MediaIcon: (_props: any) => JSX.Element;
+import React from 'react';
+declare const MediaIcon: (_props: any) => React.JSX.Element;
 export default MediaIcon;

package/es/components/molecules/UploadImage/MediaThumb.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { MediaMode } from '.';
+interface MediaThumbProps {
+    mode: MediaMode;
+    media: any;
+    index: number;
+    posters: string[];
+    onSetPosters: (newPosters: string[]) => void;
+}
+export declare const MediaThumb: React.FC<MediaThumbProps>;
+export {};

package/es/components/molecules/UploadImage/MediaThumb.js

@@ -0,0 +1,31 @@
+/* eslint-disable jsx-a11y/media-has-caption */
+// Libraries
+import React, { useEffect } from 'react';
+// Styled
+import { Image } from './styled';
+export const MediaThumb = props => {
+    const { mode, index, media, posters, onSetPosters } = props;
+    useEffect(() => {
+        let timer = null;
+        if (mode === 'video' && posters[index] !== '') {
+            const newPosters = [...posters];
+            newPosters.splice(index, 1, '');
+            timer = setTimeout(() => {
+                onSetPosters(newPosters);
+            }, 500);
+        }
+        return () => {
+            if (timer) {
+                clearTimeout(timer);
+            }
+        };
+    }, [mode, posters, index, onSetPosters]);
+    if (mode === 'image')
+        return React.createElement(Image, { src: media.url, alt: "img" });
+    return (React.createElement("video", { controls: false, width: "100%", height: "100%", autoPlay: false, poster: posters[index] || '', onCanPlay: () => {
+            const newPosters = [...posters];
+            newPosters.splice(index, 1, '');
+            onSetPosters(newPosters);
+        }, style: { position: 'absolute' } },
+        React.createElement("source", { src: media.url })));
+};

package/es/components/molecules/UploadImage/index.d.ts

@@ -1,14 +1,18 @@
 import React from 'react';
 import { UploadProps as AntdUploadProps } from 'antd/lib/upload';
+export type MediaMode = 'image' | 'video';
 interface UploadImageProps extends AntdUploadProps {
     labelHeadingModal?: string;
     labelButtonSelect?: string;
+    labelModalDelete?: string;
     searchPlaceholder?: string;
     onRemoveImage?: Function;
     onChangeImage?: Function;
-    selectedImage?: UploadImageObject;
+    selectedImage?: UploadMediaObject;
     isOpen?: boolean;
     isInputMode?: boolean;
+    iconName?: string;
+    mode?: MediaMode;
     width?: any;
     errors?: Array<any>;
     extensions?: string[];
@@ -26,7 +30,7 @@ interface UploadImageProps extends AntdUploadProps {
     required?: boolean;
     focused?: boolean;
 }
-interface UploadImageObject {
+interface UploadMediaObject {
     url: string;
 }
 export declare const UploadImage: React.FC<UploadImageProps>;

package/es/components/molecules/UploadImage/index.js

@@ -7,6 +7,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+/* eslint-disable jsx-a11y/media-has-caption */
+/* eslint-disable @typescript-eslint/no-use-before-define */
 /* eslint-disable react-hooks/exhaustive-deps */
 // Libraries
 import React, { useEffect, useState, useRef } from 'react';
@@ -17,15 +19,18 @@ import { useDeepCompareEffect } from '@antscorp/antsomi-ui/es/hooks';
 import PlaceholderImage from '@antscorp/antsomi-ui/es/assets/images/placeholder-image.png';
 import MediaIcon from './MediaIcon';
 // Service
-import { uploadFile, createSavedImage, deleteSavedImage, getListingSavedImage, } from '@antscorp/antsomi-ui/es/services/MediaTemplateDesign/UploadFile';
+import { uploadFile, createSavedMedia, deleteSavedMedia, getListingSavedMedia, } from '@antscorp/antsomi-ui/es/services/MediaTemplateDesign/UploadFile';
 // Atoms
 import { Button, Icon, Text, message, Spin, Input, Space, } from '@antscorp/antsomi-ui/es/components/atoms';
 // Molecules
 import { Modal, InputSearch, Select } from '@antscorp/antsomi-ui/es/components/molecules';
+// Components
+import { MediaThumb } from './MediaThumb';
 // Styled
 import { Boxed, ErrorMessage, Image, Overlay, Paragraph, TextStyled, UploadImageWrapper, WrapperBtn, WrapperIcon, WrapperInputMode, WrapperListImages, } from './styled';
 // Utils
 import { handleError, safeParse } from '@antscorp/antsomi-ui/es/utils';
+import { getMediaTypeByMode, getReplacementExtension } from './utils';
 // Constants
 import { THEME } from '@antscorp/antsomi-ui/es/constants';
 const flexStyleCenter = {
@@ -47,56 +52,63 @@ const SORT_OPTIONS = {
 const PATH = '@antscorp/antsomi-ui/es/components/molecules/UploadImage/index.tsx';
 export const UploadImage = props => {
     var _a, _b, _c, _d, _e;
-    const { labelHeadingModal, labelButtonSelect, searchPlaceholder, onRemoveImage, onChangeImage, isOpen, isInputMode, width, placeholder, extensions, maxSize, title, showImageURL, required, focused, domainMedia, slug, paramConfigs, errors, } = props;
+    const { labelHeadingModal, labelButtonSelect, labelModalDelete, searchPlaceholder, onRemoveImage, onChangeImage: onChangeMedia, isOpen, isInputMode, width, placeholder, extensions, maxSize, title, showImageURL: showMediaURL, selectedImage: selectedMediaProp, required, focused, domainMedia, slug, paramConfigs, errors, iconName, mode, } = props;
     const { Dragger } = Upload;
-    const [storeSavedImages, setStoreSavedImages] = useState([]);
-    const [selectedImage, setSelectedImage] = useState(props.selectedImage || { url: '' });
+    const [storeSavedMedia, setStoreSavedMedia] = useState([]);
+    const [selectedMedia, setSelectedMedia] = useState(selectedMediaProp || { url: '' });
     const [isModalVisible, setIsModalVisible] = useState(isOpen);
-    const [listImages, setListImages] = useState(storeSavedImages || []);
+    const [listMedia, setListMedia] = useState(storeSavedMedia || []);
     const [sortOption, setSortOption] = useState(SORT_OPTIONS.BY_UPLOAD_DATE.value);
     const [loading, setLoading] = useState(false);
     const [isOpenConfirmDelete, setOpenConfirmDelete] = useState(false);
     const [triggerRefresh, setTriggerRefresh] = useState(1);
+    const [posters, setPosters] = useState([]);
     const uploadFilesRef = useRef([]);
     const uploadFilesTimeoutRef = useRef();
-    const deleteImageRef = useRef();
+    const deleteMediaRef = useRef();
     const isError = safeParse(errors, []).length > 0;
     useDeepCompareEffect(() => {
-        setListImages(storeSavedImages || []);
+        setListMedia(storeSavedMedia || []);
         setLoading(false);
-    }, [storeSavedImages]);
-    // When selectedImage onChange
+    }, [storeSavedMedia]);
+    useDeepCompareEffect(() => {
+        if (mode === 'video') {
+            const genPosters = Array.from({ length: (listMedia === null || listMedia === void 0 ? void 0 : listMedia.length) || 0 }, () => PlaceholderImage);
+            setPosters(genPosters);
+        }
+    }, [listMedia]);
+    // When selectedMediaProp onChange
     useEffect(() => {
-        // eslint-disable-next-line react/destructuring-assignment
-        setSelectedImage(props.selectedImage || { url: '' });
-        // eslint-disable-next-line react/destructuring-assignment
-    }, [props.selectedImage]);
+        setSelectedMedia(selectedMediaProp || { url: '' });
+    }, [selectedMediaProp]);
     useEffect(() => {
         if (sortOption === SORT_OPTIONS.BY_SIZE.value) {
-            setListImages(listImages ? [...listImages].sort((image1, image2) => image1.size - image2.size) : []);
+            setListMedia(listMedia ? [...listMedia].sort((media1, media2) => media1.size - media2.size) : []);
         }
         else {
-            setListImages(listImages
-                ? [...listImages].sort((image1, image2) => image1.createdAt && image2.createdAt
-                    ? image1.createdAt.isAfter(image2.createdAt)
+            setListMedia(listMedia
+                ? [...listMedia].sort((media1, media2) => media1.createdAt && media2.createdAt
+                    ? media1.createdAt.isAfter(media2.createdAt)
                         ? -1
                         : 1
                     : 0)
                 : []);
         }
     }, [sortOption]);
-    const handleGetStoreSavedImages = (domain, slug, paramConfigs) => __awaiter(void 0, void 0, void 0, function* () {
+    const handleGetStoreSavedMedia = (domain, slug, paramConfigs) => __awaiter(void 0, void 0, void 0, function* () {
         try {
             setLoading(true);
-            const result = yield getListingSavedImage(domain, slug, paramConfigs);
+            const type = getMediaTypeByMode(mode);
+            const params = Object.assign(Object.assign({}, paramConfigs), { type });
+            const result = yield getListingSavedMedia(domain, slug, params);
             if (result) {
-                setStoreSavedImages(result || []);
+                setStoreSavedMedia(result || []);
             }
         }
         catch (error) {
             handleError(error, {
                 path: PATH,
-                name: 'handleGetStoreSavedImages',
+                name: 'handleGetStoreSavedMedia',
                 args: {
                     error,
                 },
@@ -109,7 +121,7 @@ export const UploadImage = props => {
         }
     });
     useEffect(() => {
-        handleGetStoreSavedImages(domainMedia, slug, paramConfigs);
+        handleGetStoreSavedMedia(domainMedia, slug, paramConfigs);
     }, [triggerRefresh]);
     const showModal = (e) => {
         e.stopPropagation();
@@ -118,24 +130,24 @@ export const UploadImage = props => {
     const handleCancel = () => {
         setIsModalVisible(false);
     };
-    const handleSelectImage = image => {
-        if (typeof onChangeImage === 'function') {
-            onChangeImage(image);
+    const handleSelectMedia = (media) => {
+        if (typeof onChangeMedia === 'function') {
+            onChangeMedia(media);
         }
-        setSelectedImage(image);
+        setSelectedMedia(media);
         handleCancel();
     };
-    const onChangeSort = option => {
+    const onChangeSort = (option) => {
         setSortOption(option);
     };
-    const renderListImages = listImagesRender => listImagesRender.map((image, idx) => {
+    const renderListMedia = (listMediaRender) => listMediaRender.map((media, idx) => {
         var _a;
         return (React.createElement(WrapperListImages, { className: "ants-group", key: idx },
             React.createElement(Boxed, null,
-                React.createElement(Image, { src: image.url, alt: "img" }),
+                React.createElement(MediaThumb, { index: idx, posters: posters, mode: mode, media: media, onSetPosters: setPosters }),
                 React.createElement(WrapperBtn, { className: "group-hover" },
-                    React.createElement(Button, { onClick: () => handleSelectImage(image), style: { backgroundColor: 'rgb(255,255,255)' } }, "USE"),
-                    React.createElement(Button, { onClick: () => handleRemoveUploadedImage(image), style: { backgroundColor: 'rgb(255,255,255)' } },
+                    React.createElement(Button, { onClick: () => handleSelectMedia(media), style: { backgroundColor: 'rgb(255,255,255)' } }, "USE"),
+                    React.createElement(Button, { onClick: () => handleRemoveUploadedMedia(media), style: { backgroundColor: 'rgb(255,255,255)' } },
                         React.createElement(Icon, { type: "icon-ants-remove-trash", size: 15, style: { color: (_a = THEME.token) === null || _a === void 0 ? void 0 : _a.colorPrimary } }))),
                 React.createElement(Overlay, { className: "group-hover" })),
             React.createElement(Paragraph, { style: {
@@ -144,63 +156,65 @@ export const UploadImage = props => {
                     display: '-webkit-box',
                     WebkitLineClamp: 2,
                     WebkitBoxOrient: 'vertical',
-                }, title: image.name }, image.name),
+                }, title: media.name }, media.name),
             React.createElement(Paragraph, null,
                 "Uploaded: ",
-                image.createdAt.format('DD/MM/YYYY'),
+                media.createdAt.format('DD/MM/YYYY'),
                 " at ",
-                image.createdAt.format('hh:mm:ss A')),
+                media.createdAt.format('hh:mm:ss A')),
             React.createElement(Paragraph, null,
                 "Size: ",
-                image.sizeString)));
+                media.sizeString)));
     });
-    const onChangeSearchImage = e => {
+    const onChangeSearchImage = (e) => {
         const { value } = e.target;
         if (value && value.trim()) {
-            setListImages(storeSavedImages
-                ? storeSavedImages
+            setListMedia(storeSavedMedia
+                ? storeSavedMedia
                     .filter(item => item.name.toLocaleLowerCase().includes(value.trim().toLocaleLowerCase()))
                     .slice(0, 15)
                 : []);
         }
         else {
-            setListImages(storeSavedImages);
+            setListMedia(storeSavedMedia);
         }
     };
-    const handleRemoveImage = () => {
+    const handleRemoveMedia = () => {
         if (onRemoveImage) {
             onRemoveImage();
         }
-        setSelectedImage({ url: '' });
+        setSelectedMedia({ url: '' });
     };
-    const handleRemoveUploadedImage = (image, isConfirm = true) => __awaiter(void 0, void 0, void 0, function* () {
+    const handleRemoveUploadedMedia = (media, isConfirm = true) => __awaiter(void 0, void 0, void 0, function* () {
         if (isConfirm) {
-            deleteImageRef.current = image;
+            deleteMediaRef.current = media;
             setOpenConfirmDelete(true);
         }
-        else if (image) {
-            const res = yield deleteSavedImage(domainMedia, slug, paramConfigs, +image.id);
+        else if (media) {
+            const res = yield deleteSavedMedia(domainMedia, slug, paramConfigs, +media.id);
             if (res && res.data && res.data.code === 200 && res.data.data) {
-                const { success_image = [] } = res.data.data;
-                if (Array.isArray(success_image) && success_image.length) {
+                const { success_media = [] } = res.data.data;
+                if (Array.isArray(success_media) && success_media.length) {
                     setTriggerRefresh(triggerRefresh + 1);
                 }
             }
             setOpenConfirmDelete(false);
-            deleteImageRef.current = undefined;
+            deleteMediaRef.current = undefined;
         }
     });
-    const renderSelectedImage = () => selectedImage && selectedImage.url ? (React.createElement(Image, { src: selectedImage.url, alt: "", style: { position: 'absolute' }, onError: (e) => {
-            e.target.src = PlaceholderImage;
-        } })) : null;
+    const renderSelectedMedia = () => {
+        if (!selectedMedia || !selectedMedia.url)
+            return null;
+        if (mode === 'video') {
+            return (React.createElement("video", { controls: false, autoPlay: false, muted: true, style: { width: '100%', height: '100%', position: 'absolute' }, src: selectedMedia.url }));
+        }
+        return (React.createElement(Image, { src: selectedMedia.url, alt: "", style: { position: 'absolute' }, onError: (e) => {
+                e.target.src = PlaceholderImage;
+            } }));
+    };
     const customRequestUpload = (options) => __awaiter(void 0, void 0, void 0, function* () {
         try {
-            const { 
-            // onSuccess,
-            //  onError,
-            file,
-            //  onProgress
-             } = options;
+            const { file } = options;
             uploadFilesRef.current.push(file);
             if (uploadFilesTimeoutRef.current) {
                 clearTimeout(uploadFilesTimeoutRef.current);
@@ -211,12 +225,15 @@ export const UploadImage = props => {
                     return;
                 }
                 if (uploadFilesRef.current.length > 10) {
-                    message.error('Maximum number of file to upload is 10!');
+                    const defaultMaxSize = mode === 'video' ? 200 : 10;
+                    const error = `Maximum number of file to upload is ${maxSize || defaultMaxSize}!`;
+                    message.error(error);
                     uploadFilesRef.current = [];
                     return false;
                 }
                 for (const file of uploadFilesRef.current) {
-                    if (!(extensions === null || extensions === void 0 ? void 0 : extensions.map(extension => extension.replace('.', 'image/')).includes(file.type))) {
+                    const replacement = getReplacementExtension(mode);
+                    if (!(extensions === null || extensions === void 0 ? void 0 : extensions.map(extension => extension.replace('.', replacement)).includes(file.type))) {
                         message.error('Invalid file extension');
                         uploadFilesRef.current = [];
                         return false;
@@ -228,16 +245,18 @@ export const UploadImage = props => {
                     }
                 }
                 setLoading(true);
-                const result = yield uploadFile(domainMedia, slug, paramConfigs, uploadFilesRef.current).finally(() => {
+                const result = yield uploadFile(domainMedia, slug, Object.assign(Object.assign({}, paramConfigs), { mode }), uploadFilesRef.current).finally(() => {
                     uploadFilesRef.current = [];
                 });
                 if (result === null || result === void 0 ? void 0 : result.length) {
                     const arrPromise = [];
-                    result.forEach(data => arrPromise.push(createSavedImage(domainMedia, slug, paramConfigs, {
-                        image_name: data.fileName,
+                    const type = getMediaTypeByMode(mode);
+                    result.forEach(data => arrPromise.push(createSavedMedia(domainMedia, slug, paramConfigs, {
+                        type,
+                        name: data.fileName,
                         properties: {
                             url: data.url,
-                            image: data.file,
+                            file: data.file,
                             extension: data.extension,
                             dimensions_file: data.dimensionsFile,
                             size: data.size,
@@ -265,23 +284,25 @@ export const UploadImage = props => {
     });
     return (React.createElement(React.Fragment, null,
         isInputMode ? (React.createElement(WrapperInputMode, { width: width },
-            React.createElement(Input, { required: required, status: errors && (errors === null || errors === void 0 ? void 0 : errors.length) > 0 ? 'error' : '', placeholder: placeholder, value: selectedImage.url ? selectedImage.url : '', focused: focused, style: { paddingRight: 40 }, onAfterChange: value => handleSelectImage({
+            React.createElement(Input, { required: required, status: errors && (errors === null || errors === void 0 ? void 0 : errors.length) > 0 ? 'error' : '', placeholder: placeholder, value: selectedMedia.url ? selectedMedia.url : '', focused: focused, style: { paddingRight: 40 }, onAfterChange: value => handleSelectMedia({
                     url: value,
                 }) }),
             React.createElement(WrapperIcon, { onClick: showModal },
                 React.createElement(MediaIcon, null)),
             isError && React.createElement(ErrorMessage, null, errors && (errors === null || errors === void 0 ? void 0 : errors.length) > 0 ? errors[0] : ''))) : (React.createElement(UploadImageWrapper, null,
             title ? React.createElement(Text, { style: { marginTop: 10 } }, title) : null,
-            React.createElement("div", { className: `image-upload-content ${selectedImage && selectedImage.url ? 'uploaded' : ''}` },
-                renderSelectedImage(),
-                !selectedImage || !selectedImage.url ? (React.createElement(Icon, { type: "icon-ants-image-3", size: 36, style: {
+            React.createElement("div", { className: `image-upload-content ${selectedMedia && selectedMedia.url ? 'uploaded' : ''}` },
+                renderSelectedMedia(),
+                !selectedMedia || !selectedMedia.url ? (React.createElement(Icon, { type: `icon-ants-${iconName}`, size: 36, style: {
                         zIndex: 1,
                         marginLeft: 25,
                         color: (_a = THEME.token) === null || _a === void 0 ? void 0 : _a.colorIcon,
                     } })) : null,
                 React.createElement("div", { style: flexStyleCenter },
-                    React.createElement(Button, { onClick: showModal, style: { backgroundColor: '#ffffff' } }, "Browse Image"),
-                    selectedImage && selectedImage.url ? (React.createElement(Button, { onClick: handleRemoveImage, style: { backgroundColor: '#ffffff' } },
+                    React.createElement(Button, { onClick: showModal, style: { backgroundColor: '#ffffff' } },
+                        "Browse ",
+                        mode === 'video' ? 'Video' : 'Image'),
+                    selectedMedia && selectedMedia.url ? (React.createElement(Button, { onClick: handleRemoveMedia, style: { backgroundColor: '#ffffff' } },
                         React.createElement(Icon, { type: "icon-ants-remove-trash", size: 15, style: { color: (_b = THEME.token) === null || _b === void 0 ? void 0 : _b.colorPrimary } }))) : null)),
             React.createElement("div", { className: "upload-file-info", style: { marginTop: 12 } },
                 React.createElement(Text, null,
@@ -291,17 +312,17 @@ export const UploadImage = props => {
                     "File size: under ",
                     maxSize,
                     "MB")),
-            showImageURL && (React.createElement(Space, { size: 5, direction: "vertical", style: { marginTop: 12 } },
-                React.createElement(Input, { label: "Image URL", required: required, placeholder: placeholder, value: selectedImage.url ? selectedImage.url : '', focused: focused, onAfterChange: value => handleSelectImage({
+            showMediaURL && (React.createElement(Space, { size: 5, direction: "vertical", style: { marginTop: 12 } },
+                React.createElement(Input, { label: mode === 'video' ? 'Video URL' : 'Image URL', required: required, placeholder: placeholder, value: selectedMedia.url ? selectedMedia.url : '', focused: focused, onAfterChange: value => handleSelectMedia({
                         url: value,
                     }) }))))),
-        React.createElement(Modal, { title: "Delete Image", visible: isOpenConfirmDelete, onOk: () => handleRemoveUploadedImage(deleteImageRef.current, false), onCancel: () => setOpenConfirmDelete(prev => !prev), okText: "OK", cancelText: "Cancel" },
+        React.createElement(Modal, { title: labelModalDelete, visible: isOpenConfirmDelete, onOk: () => handleRemoveUploadedMedia(deleteMediaRef.current, false), onCancel: () => setOpenConfirmDelete(prev => !prev), okText: "OK", cancelText: "Cancel" },
             React.createElement("p", null,
-                "Are you sure you want to delete the image ", (_c = deleteImageRef.current) === null || _c === void 0 ? void 0 :
+                "Are you sure you want to delete ", (_c = deleteMediaRef.current) === null || _c === void 0 ? void 0 :
                 _c.name,
                 "?")),
         React.createElement(Modal, { wrapClassName: "icons-selection-modal", title: React.createElement("div", { style: { display: 'flex', gap: '8px', alignItems: 'center' } },
-                React.createElement(Icon, { type: "icon-ants-image-3", size: 20 }),
+                React.createElement(Icon, { type: `icon-ants-${iconName}`, size: 20 }),
                 labelHeadingModal), centered: true, headerStyle: {
                 padding: '20px 20px 0',
                 border: 'none',
@@ -326,12 +347,12 @@ export const UploadImage = props => {
                     // onChange={onChangeFileUpload}
                     showUploadList: false, multiple: true, customRequest: customRequestUpload }),
                     React.createElement("div", { style: Object.assign(Object.assign({}, flexStyleCenter), { height: 80 }) },
-                        React.createElement(Icon, { type: "icon-ants-image-3", size: 36, style: { color: (_d = THEME.token) === null || _d === void 0 ? void 0 : _d.colorIcon } }),
+                        React.createElement(Icon, { type: `icon-ants-${iconName}`, size: 36, style: { color: (_d = THEME.token) === null || _d === void 0 ? void 0 : _d.colorIcon } }),
                         React.createElement("div", { style: Object.assign(Object.assign({}, flexStyleCenter), { justifyContent: 'flex-start' }) },
                             React.createElement(TextStyled, { className: "ant-upload-text" }, "Drag & Drop file here"),
                             React.createElement("span", null, "or"),
                             React.createElement(Button, { style: { backgroundColor: '#ffffff' } }, labelButtonSelect),
-                            React.createElement(Button, { onClick: handleRemoveImage, style: {
+                            React.createElement(Button, { onClick: handleRemoveMedia, style: {
                                     display: 'none !important',
                                     backgroundColor: '#ffffff',
                                 } },
@@ -342,16 +363,19 @@ export const UploadImage = props => {
                     gap: '35px',
                     paddingTop: 20,
                     width: '100%',
-                } }, renderListImages(listImages)))));
+                } }, renderListMedia(listMedia)))));
 };
 UploadImage.defaultProps = {
     isOpen: false,
     labelHeadingModal: 'Image Selection',
     labelButtonSelect: 'Select Image from computer',
+    labelModalDelete: 'Delete Image',
     searchPlaceholder: 'Search image...',
     domainMedia: 'https://sandbox-media-template.antsomi.com/cdp',
     slug: 'api/v1',
     isInputMode: true,
+    iconName: 'image-3',
+    mode: 'image',
     width: '100%',
     errors: [],
     placeholder: 'Enter image URL',

package/es/components/molecules/UploadImage/styled.js

@@ -29,10 +29,6 @@ export const Boxed = styled.div `
   border-style: solid;
   --tw-border-opacity: 1;
   border-color: rgb(224 224 224 / var(--tw-border-opacity));
-
-  &:hover {
-    border-width: 2px;
-  }
 `;
 export const Image = styled.img `
   object-fit: contain;