init

src/redux/combineReducers.ts

@@ -0,0 +1,24 @@
+import {
+    combineReducers as combine,
+    ReducersMapObject,
+    AnyAction,
+} from "redux";
+import invariant from "invariant";
+
+export const combineReducers = (reducers: ReducersMapObject) => {
+    const combinedReducer = combine(reducers);
+    // TODO: define state type
+    return (state: any, action: AnyAction) => {
+        if (
+            action.type &&
+            !action.type.startsWith("@@") &&
+            action.type.split("/").length > 1
+        ) {
+            const namespace = action.type.split("/")[0];
+            const reducer = reducers[namespace];
+            invariant(!!reducer, `reducer ${namespace} doesn't exist`);
+            return reducer && reducer(state, action);
+        }
+        return combinedReducer(state, action);
+    };
+};

src/redux/explorer/async.ts

@@ -0,0 +1,88 @@
+import { ThunkAction } from "redux-thunk";
+import Auth from "../../middleware/Auth";
+import pathHelper from "../../utils/page";
+import { closeAllModals, confirmPurchase, toggleSnackbar } from "./index";
+import { setOptionModal } from "../viewUpdate/action";
+import i18next from "../../i18n";
+
+export const askForOption = (
+    options: any,
+    title: string
+): ThunkAction<any, any, any, any> => {
+    return async (dispatch, getState): Promise<any> => {
+        return new Promise<void>((resolve, reject) => {
+            const dialog = {
+                open: true,
+                title: title,
+                options: options,
+            };
+            dispatch(
+                setOptionModal({
+                    ...dialog,
+                    onClose: () => {
+                        dispatch(setOptionModal({ ...dialog, open: false }));
+                        reject(i18next.t("fileManager.userDenied"));
+                    },
+                    callback: (option: any) => {
+                        resolve(option);
+                        dispatch(setOptionModal({ ...dialog, open: false }));
+                    },
+                })
+            );
+        });
+    };
+};
+
+const purchased = new Map<string, boolean>();
+
+export const trySharePurchase = (
+    share: any
+): ThunkAction<any, any, any, any> => {
+    return async (dispatch, getState): Promise<void> => {
+        return new Promise<void>((resolve, reject) => {
+            const {
+                router: {
+                    location: { pathname },
+                },
+            } = getState();
+            if (pathHelper.isSharePage(pathname) && share && share.score > 0) {
+                if (!Auth.Check()) {
+                    dispatch(
+                        toggleSnackbar(
+                            "top",
+                            "right",
+                            i18next.t("share.pleaseLogin"),
+                            "warning"
+                        )
+                    );
+                    dispatch(closeAllModals());
+                    reject(i18next.t("fileManager.userDenied"));
+                    return;
+                }
+
+                if (
+                    !Auth.GetUser().group.shareFree &&
+                    !purchased.has(share.key)
+                ) {
+                    dispatch(
+                        confirmPurchase({
+                            score: share.score,
+                            onClose: () => {
+                                dispatch(confirmPurchase(undefined));
+                                reject(i18next.t("fileManager.userDenied"));
+                            },
+                            callback: () => {
+                                purchased.set(share.key, true);
+                                resolve();
+                                dispatch(confirmPurchase(undefined));
+                            },
+                        })
+                    );
+                    return;
+                }
+            }
+
+            resolve();
+        });
+    };
+};

src/redux/explorer/index.ts

@@ -0,0 +1,300 @@
+import * as actions from "./action";
+import * as reducers from "./reducer";
+import { setPagination } from "../viewUpdate/action";
+
+export default {
+    actions,
+    reducers,
+};
+export { selectFile } from "./action";
+export { openPreview } from "./action";
+export { setShiftSelectedIds } from "./action";
+export { setLastSelect } from "./action";
+export { setSelectedTarget } from "./action";
+export { addSelectedTargets } from "./action";
+export { removeSelectedTargets } from "./action";
+export const setNavigator = (path: any, navigatorLoading: any) => {
+    return {
+        type: "SET_NAVIGATOR",
+        path,
+        navigatorLoading,
+    };
+};
+export const navigateTo = (path: any) => {
+    return (dispatch: any, getState: any) => {
+        const state = getState();
+        const navigatorLoading = path !== state.navigator.path;
+        if (navigatorLoading) {
+            dispatch(
+                setPagination({
+                    ...state.viewUpdate.pagination,
+                    page: 1,
+                })
+            );
+        }
+        dispatch(setNavigator(path, navigatorLoading));
+    };
+};
+export const navigateUp = () => {
+    return (dispatch, getState) => {
+        const state = getState();
+        const pathSplit = state.navigator.path.split("/");
+        pathSplit.pop();
+        const newPath = pathSplit.length === 1 ? "/" : pathSplit.join("/");
+        const navigatorLoading = newPath !== state.navigator.path;
+        if (navigatorLoading) {
+            dispatch(
+                setPagination({
+                    ...state.viewUpdate.pagination,
+                    page: 1,
+                })
+            );
+        }
+        dispatch(setNavigator(newPath, navigatorLoading));
+    };
+};
+export const drawerToggleAction = (open) => {
+    return {
+        type: "DRAWER_TOGGLE",
+        open: open,
+    };
+};
+export const dragAndDrop = (source, target) => {
+    return {
+        type: "DRAG_AND_DROP",
+        source: source,
+        target: target,
+    };
+};
+export const changeViewMethod = (method) => {
+    return {
+        type: "CHANGE_VIEW_METHOD",
+        method: method,
+    };
+};
+export const toggleDaylightMode = () => {
+    return {
+        type: "TOGGLE_DAYLIGHT_MODE",
+    };
+};
+// Deprecated
+export const changeContextMenu = (type, open) => {
+    return {
+        type: "CHANGE_CONTEXT_MENU",
+        menuType: type,
+        open: open,
+    };
+};
+export const setNavigatorLoadingStatus = (status) => {
+    return {
+        type: "SET_NAVIGATOR_LOADING_STATUE",
+        status: status,
+    };
+};
+export const setNavigatorError = (status, msg) => {
+    return {
+        type: "SET_NAVIGATOR_ERROR",
+        status: status,
+        msg: msg,
+    };
+};
+export const openCreateFolderDialog = () => {
+    return {
+        type: "OPEN_CREATE_FOLDER_DIALOG",
+    };
+};
+export const openCreateFileDialog = () => {
+    return {
+        type: "OPEN_CREATE_FILE_DIALOG",
+    };
+};
+export const setUserPopover = (anchor) => {
+    return {
+        type: "SET_USER_POPOVER",
+        anchor: anchor,
+    };
+};
+export const setShareUserPopover = (anchor) => {
+    return {
+        type: "SET_SHARE_USER_POPOVER",
+        anchor: anchor,
+    };
+};
+export const openRenameDialog = () => {
+    return {
+        type: "OPEN_RENAME_DIALOG",
+    };
+};
+export const openResaveDialog = (key) => {
+    return {
+        type: "OPEN_RESAVE_DIALOG",
+        key: key,
+    };
+};
+export const openMoveDialog = () => {
+    return {
+        type: "OPEN_MOVE_DIALOG",
+    };
+};
+export const openRemoveDialog = () => {
+    return {
+        type: "OPEN_REMOVE_DIALOG",
+    };
+};
+export const openShareDialog = () => {
+    return {
+        type: "OPEN_SHARE_DIALOG",
+    };
+};
+export const applyThemes = (theme) => {
+    return {
+        type: "APPLY_THEME",
+        theme: theme,
+    };
+};
+export const setSessionStatus = (status) => {
+    return {
+        type: "SET_SESSION_STATUS",
+        status: status,
+    };
+};
+export const openMusicDialog = () => {
+    return {
+        type: "OPEN_MUSIC_DIALOG",
+    };
+};
+export const openRemoteDownloadDialog = () => {
+    return {
+        type: "OPEN_REMOTE_DOWNLOAD_DIALOG",
+    };
+};
+export const openTorrentDownloadDialog = (selected) => {
+    return {
+        type: "OPEN_TORRENT_DOWNLOAD_DIALOG",
+        selected:selected,
+    };
+};
+export const openDecompressDialog = () => {
+    return {
+        type: "OPEN_DECOMPRESS_DIALOG",
+    };
+};
+export const openCompressDialog = () => {
+    return {
+        type: "OPEN_COMPRESS_DIALOG",
+    };
+};
+export const openRelocateDialog = () => {
+    return {
+        type: "OPEN_RELOCATE_DIALOG",
+    };
+};
+export const openGetSourceDialog = (source) => {
+    return {
+        type: "OPEN_GET_SOURCE_DIALOG",
+        source,
+    };
+};
+export const openCopyDialog = () => {
+    return {
+        type: "OPEN_COPY_DIALOG",
+    };
+};
+// Deprecated
+export const openLoadingDialog = (text) => {
+    return {
+        type: "OPEN_LOADING_DIALOG",
+        text: text,
+    };
+};
+// Deprecated
+export const closeAllModals = () => {
+    return {
+        type: "CLOSE_ALL_MODALS",
+    };
+};
+export const toggleSnackbar = (vertical, horizontal, msg, color) => {
+    return {
+        type: "TOGGLE_SNACKBAR",
+        vertical: vertical,
+        horizontal: horizontal,
+        msg: msg,
+        color: color,
+    };
+};
+export const setModalsLoading = (status) => {
+    return {
+        type: "SET_MODALS_LOADING",
+        status: status,
+    };
+};
+export const refreshFileList = () => {
+    return {
+        type: "REFRESH_FILE_LIST",
+    };
+};
+export const searchMyFile = (keywords, path) => {
+    return {
+        type: "SEARCH_MY_FILE",
+        keywords: keywords,
+        path: path,
+    };
+};
+export const showImgPreivew = (first) => {
+    return {
+        type: "SHOW_IMG_PREIVEW",
+        first: first,
+    };
+};
+export const showAudioPreview = (first) => {
+    return {
+        type: "SHOW_AUDIO_PREVIEW",
+        first: first,
+    };
+};
+export const audioPreviewSetIsOpen = (isOpen) => {
+    return {
+        type: "AUDIO_PREVIEW_SET_IS_OPEN",
+        isOpen,
+    };
+};
+export const audioPreviewSetPlaying = (playingName, paused) => {
+    return {
+        type: "AUDIO_PREVIEW_SET_PLAYING",
+        playingName, //the playing content name
+        paused,
+    };
+};
+export const refreshStorage = () => {
+    return {
+        type: "REFRESH_STORAGE",
+    };
+};
+export const saveFile = () => {
+    return {
+        type: "SAVE_FILE",
+    };
+};
+
+export const setSiteConfig = (config) => {
+    return {
+        type: "SET_SITE_CONFIG",
+        config: config,
+    };
+};
+
+export const openDirectoryDownloadDialog = (downloading, log, done) => {
+    return {
+        type: "OPEN_DIRECTORY_DOWNLOAD_DIALOG",
+        downloading,
+        log,
+        done,
+    };
+};
+
+export const confirmPurchase = (purchase) => {
+    return {
+        type: "CONFIRM_PURCHASE",
+        purchase: purchase,
+    };
+};

src/redux/explorer/reducer.ts

@@ -0,0 +1,278 @@
+/* eslint-disable no-case-declarations */
+import { AnyAction } from "redux";
+import { CloudreveFile } from "../../types";
+import { Policy } from "../../component/Uploader/core/types";
+
+interface SelectProps {
+    isMultiple: boolean;
+    withFolder: boolean;
+    withFile: boolean;
+    withSourceEnabled: boolean;
+}
+
+export interface ExplorerState {
+    dndSignal: boolean;
+    dndTarget: any;
+    dndSource: any;
+    fileList: CloudreveFile[];
+    dirList: CloudreveFile[];
+    selected: CloudreveFile[];
+    selectProps: SelectProps;
+    lastSelect: {
+        file: CloudreveFile;
+        index: number;
+    };
+    shiftSelectedIds: string[];
+    imgPreview: {
+        first: CloudreveFile;
+        other: [];
+    };
+    audioPreview: {
+        first: CloudreveFile;
+        other: [];
+        playingName: any;
+        paused: boolean;
+        isOpen: boolean;
+    };
+    search?: {
+        keywords: string;
+        searchPath: string;
+    };
+    fileSave: boolean;
+    sideBarOpen: boolean;
+    currentPolicy?: Policy;
+    purchase?: {
+        callback: any;
+        onClose: any;
+        score: number;
+    };
+}
+
+export const initState: ExplorerState = {
+    dndSignal: false,
+    dndTarget: null,
+    dndSource: null,
+    fileList: [],
+    dirList: [],
+    selected: [],
+    selectProps: {
+        isMultiple: false,
+        withFolder: false,
+        withFile: false,
+        withSourceEnabled: false,
+    },
+    lastSelect: {
+        file: {
+            id: "",
+            name: "",
+            size: 0,
+            type: "file",
+            date: "",
+            path: "",
+            create_date: "",
+        },
+        index: -1,
+    },
+    shiftSelectedIds: [],
+    imgPreview: {
+        first: {
+            id: "",
+            name: "",
+            size: 0,
+            type: "file",
+            date: "",
+            path: "",
+            create_date: "",
+        },
+        other: [],
+    },
+    audioPreview: {
+        first: {
+            id: "",
+            name: "",
+            size: 0,
+            type: "file",
+            date: "",
+            path: "",
+            create_date: "",
+        },
+        other: [],
+        playingName: null,
+        paused: false,
+        isOpen: false,
+    },
+    fileSave: false,
+    sideBarOpen: false,
+};
+
+const checkSelectedProps = (selected: CloudreveFile[]): SelectProps => {
+    const isMultiple = selected.length > 1;
+    let withFolder = false;
+    let withFile = false;
+    let withSourceEnabled = false;
+    selected.forEach((value) => {
+        if (value.type === "dir") {
+            withFolder = true;
+            withSourceEnabled = true;
+        } else if (value.type === "file") {
+            withFile = true;
+            if (value.source_enabled) {
+                withSourceEnabled = true;
+            }
+        }
+    });
+    return {
+        isMultiple,
+        withFolder,
+        withFile,
+        withSourceEnabled,
+    };
+};
+
+const explorer = (
+    state: ExplorerState = initState,
+    action: AnyAction
+): ExplorerState => {
+    switch (action.type) {
+        case "DRAG_AND_DROP":
+            return Object.assign({}, state, {
+                dndSignal: !state.dndSignal,
+                dndTarget: action.target,
+                dndSource: action.source,
+            });
+        case "SET_FILE_LIST":
+            return Object.assign({}, state, {
+                fileList: action.list,
+            });
+        case "SET_DIR_LIST":
+            return Object.assign({}, state, {
+                dirList: action.list,
+            });
+        case "ADD_SELECTED_TARGETS":
+            const addedSelected = [...state.selected, ...action.targets];
+            return Object.assign({}, state, {
+                selected: addedSelected,
+                selectProps: checkSelectedProps(addedSelected),
+            });
+        case "SET_SELECTED_TARGET":
+            const newSelected = action.targets;
+            return Object.assign({}, state, {
+                selected: newSelected,
+                selectProps: checkSelectedProps(newSelected),
+            });
+        case "RMOVE_SELECTED_TARGETS":
+            const { fileIds } = action;
+            const filteredSelected = state.selected.filter((file) => {
+                return !fileIds.includes(file.id);
+            });
+            return Object.assign({}, state, {
+                selected: filteredSelected,
+                selectProps: checkSelectedProps(filteredSelected),
+            });
+        case "REFRESH_FILE_LIST":
+            return Object.assign({}, state, {
+                selected: [],
+                selectProps: {
+                    isMultiple: false,
+                    withFolder: false,
+                    withFile: false,
+                    withSourceEnabled: false,
+                },
+            });
+        case "SEARCH_MY_FILE":
+            return Object.assign({}, state, {
+                selected: [],
+                selectProps: {
+                    isMultiple: false,
+                    withFolder: false,
+                    withFile: false,
+                    withSourceEnabled: false,
+                },
+                search: {
+                    keywords: action.keywords,
+                    searchPath: action.path,
+                },
+            });
+        case "SHOW_IMG_PREIVEW":
+            return Object.assign({}, state, {
+                imgPreview: {
+                    first: action.first,
+                    other: state.fileList,
+                },
+            });
+        case "SHOW_AUDIO_PREVIEW":
+            return Object.assign({}, state, {
+                audioPreview: {
+                    ...state.audioPreview,
+                    first: action.first,
+                    other: state.fileList,
+                },
+            });
+        case "AUDIO_PREVIEW_SET_IS_OPEN":
+            return Object.assign({}, state, {
+                audioPreview: {
+                    ...state.audioPreview,
+                    isOpen: action.isOpen,
+                },
+            });
+        case "AUDIO_PREVIEW_SET_PLAYING":
+            return Object.assign({}, state, {
+                audioPreview: {
+                    ...state.audioPreview,
+                    playingName: action.playingName,
+                    paused: action.paused,
+                },
+            });
+        case "SAVE_FILE":
+            return {
+                ...state,
+                fileSave: !state.fileSave,
+            };
+        case "SET_LAST_SELECT":
+            const { file, index } = action;
+            return {
+                ...state,
+                lastSelect: {
+                    file,
+                    index,
+                },
+            };
+        case "SET_SHIFT_SELECTED_IDS":
+            const { shiftSelectedIds } = action;
+            return {
+                ...state,
+                shiftSelectedIds,
+            };
+        case "SET_NAVIGATOR":
+            return {
+                ...state,
+                selected: [],
+                selectProps: {
+                    isMultiple: false,
+                    withFolder: false,
+                    withFile: false,
+                    withSourceEnabled: false,
+                },
+                search: undefined,
+            };
+        case "SET_SIDE_BAR":
+            return {
+                ...state,
+                sideBarOpen: action.open,
+            };
+        case "SET_CURRENT_POLICY":
+            return {
+                ...state,
+                currentPolicy: action.policy,
+            };
+        case "CONFIRM_PURCHASE":
+            return {
+                ...state,
+                purchase: action.purchase,
+            };
+        default:
+            return state;
+    }
+};
+
+export default explorer;

src/redux/viewUpdate/action.ts

@@ -0,0 +1,127 @@
+import { ThunkAction } from "redux-thunk";
+import { AnyAction } from "redux";
+import Auth from "../../middleware/Auth";
+import { askForOption } from "../explorer/async";
+import i18next, { languages } from "../../i18n";
+
+export interface ActionSetSubtitle extends AnyAction {
+    type: "SET_SUBTITLE";
+    title: string;
+}
+
+export const setSubtitle = (title: string): ActionSetSubtitle => {
+    return {
+        type: "SET_SUBTITLE",
+        title,
+    };
+};
+
+export const closeContextMenu = () => {
+    return {
+        type: "CLOSE_CONTEXT_MENU",
+    };
+};
+
+export const changeContextMenu = (type: string, open: boolean) => {
+    return {
+        type: "CHANGE_CONTEXT_MENU",
+        menuType: type,
+        open: open,
+    };
+};
+
+export const changeSubTitle = (
+    title: string
+): ThunkAction<any, any, any, any> => {
+    return (dispatch, getState) => {
+        const state = getState();
+        document.title =
+            title === null || title === undefined
+                ? state.siteConfig.title
+                : title + " - " + state.siteConfig.title;
+        dispatch(setSubtitle(title));
+    };
+};
+
+export const setOptionModal = (option: any) => {
+    return {
+        type: "SET_OPTION_MODAL",
+        option: option,
+    };
+};
+
+export const openFileSelector = () => {
+    return {
+        type: "OPEN_FILE_SELECTOR",
+    };
+};
+
+export const openFolderSelector = () => {
+    return {
+        type: "OPEN_FOLDER_SELECTOR",
+    };
+};
+
+export const setPagination = (pagination) => {
+    return {
+        type: "SET_PAGINATION",
+        pagination: pagination,
+    };
+};
+
+export const setShareInfo = (shareInfo) => {
+    return {
+        type: "SET_SHARE_INFO",
+        shareInfo: shareInfo,
+    };
+};
+
+export const changePageSize = (
+    size: number
+): ThunkAction<any, any, any, any> => {
+    return (dispatch, getState) => {
+        const {
+            explorer: { dirList, fileList },
+            viewUpdate: { pagination },
+        } = getState();
+        const total = dirList.length + fileList.length;
+        let page = pagination.page;
+        if (pagination.page * size > total) {
+            page = Math.max(Math.ceil(total / size), 1);
+        } else if (size === -1) {
+            page = 1;
+        }
+        Auth.SetPreference("pagination", size);
+        dispatch(
+            setPagination({
+                ...pagination,
+                size: size,
+                page: page,
+            })
+        );
+    };
+};
+
+export const selectLanguage = (): ThunkAction<any, any, any, any> => {
+    return async (dispatch, getState) => {
+        let option: any;
+        let lng = "";
+        try {
+            const allOptions = languages.map((e) => {
+                return {
+                    key: e.code,
+                    name: e.displayName,
+                };
+            });
+            option = await dispatch(
+                askForOption(allOptions, i18next.t("setting.language"))
+            );
+        } catch (e) {
+            console.log(e);
+            return;
+        }
+
+        lng = option.key;
+        await i18next.changeLanguage(lng);
+    };
+};

src/redux/viewUpdate/index.ts

@@ -0,0 +1,7 @@
+import * as actions from "./action";
+import * as reducers from "./reducer";
+
+export default {
+    actions,
+    reducers,
+};

src/redux/viewUpdate/reducer.ts

@@ -0,0 +1,396 @@
+import { AnyAction } from "redux";
+import Auth from "../../middleware/Auth";
+import { CloudreveFile, SortMethod } from "../../types";
+
+declare global {
+    interface Window {
+        shareKey: any;
+    }
+}
+
+export interface ViewUpdateState {
+    isLogin: boolean;
+    open: boolean;
+    explorerViewMethod: string;
+    sortMethod: SortMethod;
+    subTitle: string | null;
+    contextType: string;
+    contextOpen: boolean;
+    menuOpen: boolean;
+    navigatorLoading: boolean;
+    navigatorError: boolean;
+    navigatorErrorMsg: string | null;
+    modalsLoading: boolean;
+    storageRefresh: boolean;
+    userPopoverAnchorEl: any;
+    shareUserPopoverAnchorEl: any;
+    modals: {
+        createNewFolder: boolean;
+        createNewFile: boolean;
+        rename: boolean;
+        move: boolean;
+        remove: boolean;
+        share: boolean;
+        music: boolean;
+        remoteDownload: boolean;
+        remoteDownloadTorrent: CloudreveFile | null;
+        getSource: string;
+        copy: boolean;
+        resave: boolean;
+        compress: boolean;
+        decompress: boolean;
+        relocate: boolean;
+        loading: boolean;
+        loadingText: string;
+        directoryDownloading: boolean;
+        directoryDownloadLog: string;
+        directoryDownloadDone: boolean;
+        option?: {
+            options: {
+                open: boolean;
+                key: string;
+                name: string;
+                description?: string;
+            }[];
+            title: string;
+            callback: any;
+            onClose: any;
+        };
+    };
+    snackbar: {
+        toggle: boolean;
+        vertical: string;
+        horizontal: string;
+        msg: string;
+        color: string;
+    };
+    pagination: {
+        page: number;
+        size: number;
+    };
+    openFileSelector: number;
+    openFolderSelector: number;
+    shareInfo: any;
+}
+export const initState: ViewUpdateState = {
+    // 是否登录
+    isLogin: Auth.Check(),
+    open: false,
+    explorerViewMethod: "icon",
+    sortMethod: Auth.GetPreferenceWithDefault("sort", "timePos"),
+    subTitle: null,
+    contextType: "none",
+    contextOpen: false,
+    menuOpen: false,
+    navigatorLoading: true,
+    navigatorError: false,
+    navigatorErrorMsg: null,
+    modalsLoading: false,
+    storageRefresh: false,
+    userPopoverAnchorEl: null,
+    shareUserPopoverAnchorEl: null,
+    modals: {
+        createNewFolder: false,
+        createNewFile: false,
+        rename: false,
+        move: false,
+        remove: false,
+        share: false,
+        music: false,
+        remoteDownload: false,
+        remoteDownloadTorrent: null,
+        getSource: "",
+        copy: false,
+        resave: false,
+        compress: false,
+        relocate: false,
+        decompress: false,
+        loading: false,
+        loadingText: "",
+        directoryDownloading: false,
+        directoryDownloadLog: "",
+        directoryDownloadDone: false,
+    },
+    snackbar: {
+        toggle: false,
+        vertical: "top",
+        horizontal: "center",
+        msg: "",
+        color: "",
+    },
+    pagination: {
+        page: 1,
+        size: Auth.GetPreferenceWithDefault("pagination", 100),
+    },
+    openFileSelector: 0,
+    openFolderSelector: 0,
+    shareInfo: null,
+};
+const viewUpdate = (state: ViewUpdateState = initState, action: AnyAction) => {
+    switch (action.type) {
+        case "DRAWER_TOGGLE":
+            return Object.assign({}, state, {
+                open: action.open,
+            });
+        case "CHANGE_VIEW_METHOD":
+            return Object.assign({}, state, {
+                explorerViewMethod: action.method,
+            });
+        case "SET_NAVIGATOR_LOADING_STATUE":
+            return Object.assign({}, state, {
+                navigatorLoading: action.status,
+            });
+        case "SET_NAVIGATOR_ERROR":
+            return Object.assign({}, state, {
+                navigatorError: action.status,
+                navigatorErrorMsg: action.msg,
+            });
+        case "OPEN_CREATE_FOLDER_DIALOG":
+            return Object.assign({}, state, {
+                modals: Object.assign({}, state.modals, {
+                    createNewFolder: true,
+                }),
+                contextOpen: false,
+            });
+        case "OPEN_CREATE_FILE_DIALOG":
+            return Object.assign({}, state, {
+                modals: Object.assign({}, state.modals, {
+                    createNewFile: true,
+                }),
+                contextOpen: false,
+            });
+        case "OPEN_RENAME_DIALOG":
+            return Object.assign({}, state, {
+                modals: Object.assign({}, state.modals, {
+                    rename: true,
+                }),
+                contextOpen: false,
+            });
+        case "OPEN_REMOVE_DIALOG":
+            return Object.assign({}, state, {
+                modals: Object.assign({}, state.modals, {
+                    remove: true,
+                }),
+                contextOpen: false,
+            });
+        case "OPEN_MOVE_DIALOG":
+            return Object.assign({}, state, {
+                modals: Object.assign({}, state.modals, {
+                    move: true,
+                }),
+                contextOpen: false,
+            });
+        case "OPEN_RESAVE_DIALOG":
+            window.shareKey = action.key;
+            return Object.assign({}, state, {
+                modals: Object.assign({}, state.modals, {
+                    resave: true,
+                }),
+                contextOpen: false,
+            });
+        case "SET_USER_POPOVER":
+            return Object.assign({}, state, {
+                userPopoverAnchorEl: action.anchor,
+            });
+        case "SET_SHARE_USER_POPOVER":
+            return Object.assign({}, state, {
+                shareUserPopoverAnchorEl: action.anchor,
+            });
+        case "OPEN_SHARE_DIALOG":
+            return Object.assign({}, state, {
+                modals: Object.assign({}, state.modals, {
+                    share: true,
+                }),
+                contextOpen: false,
+            });
+        case "OPEN_MUSIC_DIALOG":
+            return Object.assign({}, state, {
+                modals: Object.assign({}, state.modals, {
+                    music: true,
+                }),
+                contextOpen: false,
+            });
+        case "OPEN_REMOTE_DOWNLOAD_DIALOG":
+            return Object.assign({}, state, {
+                modals: Object.assign({}, state.modals, {
+                    remoteDownload: true,
+                }),
+                contextOpen: false,
+            });
+        case "OPEN_TORRENT_DOWNLOAD_DIALOG":
+            return Object.assign({}, state, {
+                modals: Object.assign({}, state.modals, {
+                    remoteDownload: true,
+                    remoteDownloadTorrent: action.selected,
+                }),
+                contextOpen: false,
+            });
+        case "OPEN_DECOMPRESS_DIALOG":
+            return Object.assign({}, state, {
+                modals: Object.assign({}, state.modals, {
+                    decompress: true,
+                }),
+                contextOpen: false,
+            });
+        case "OPEN_COMPRESS_DIALOG":
+            return Object.assign({}, state, {
+                modals: Object.assign({}, state.modals, {
+                    compress: true,
+                }),
+                contextOpen: false,
+            });
+        case "OPEN_GET_SOURCE_DIALOG":
+            return Object.assign({}, state, {
+                modals: Object.assign({}, state.modals, {
+                    getSource: action.source,
+                }),
+                contextOpen: false,
+            });
+        case "OPEN_RELOCATE_DIALOG":
+            return Object.assign({}, state, {
+                modals: Object.assign({}, state.modals, {
+                    relocate: true,
+                }),
+                contextOpen: false,
+            });
+        case "OPEN_COPY_DIALOG":
+            return Object.assign({}, state, {
+                modals: Object.assign({}, state.modals, {
+                    copy: true,
+                }),
+                contextOpen: false,
+            });
+        case "OPEN_LOADING_DIALOG":
+            return Object.assign({}, state, {
+                modals: Object.assign({}, state.modals, {
+                    loading: true,
+                    loadingText: action.text,
+                }),
+                contextOpen: false,
+            });
+        case "OPEN_DIRECTORY_DOWNLOAD_DIALOG":
+            return Object.assign({}, state, {
+                modals: Object.assign({}, state.modals, {
+                    directoryDownloading: action.downloading,
+                    directoryDownloadLog: action.log,
+                    directoryDownloadDone: action.done,
+                }),
+                contextOpen: false,
+            });
+        case "CLOSE_CONTEXT_MENU":
+            return Object.assign({}, state, {
+                contextOpen: false,
+            });
+        case "CLOSE_ALL_MODALS":
+            return Object.assign({}, state, {
+                modals: Object.assign({}, state.modals, {
+                    createNewFolder: false,
+                    createNewFile: false,
+                    rename: false,
+                    move: false,
+                    remove: false,
+                    share: false,
+                    music: false,
+                    remoteDownload: false,
+                    remoteDownloadTorrent: null,
+                    getSource: "",
+                    resave: false,
+                    copy: false,
+                    loading: false,
+                    relocate: false,
+                    compress: false,
+                    decompress: false,
+                    option: undefined,
+                    directoryDownloading: false,
+                    directoryDownloadLog: "",
+                    directoryDownloadDone: false,
+                }),
+            });
+        case "TOGGLE_SNACKBAR":
+            return Object.assign({}, state, {
+                snackbar: {
+                    toggle: !state.snackbar.toggle,
+                    vertical: action.vertical,
+                    horizontal: action.horizontal,
+                    msg: action.msg,
+                    color: action.color,
+                },
+            });
+        case "SET_MODALS_LOADING":
+            return Object.assign({}, state, {
+                modalsLoading: action.status,
+            });
+        case "SET_SESSION_STATUS":
+            return {
+                ...state,
+                isLogin: action.status,
+            };
+        case "REFRESH_STORAGE":
+            return Object.assign({}, state, {
+                storageRefresh: !state.storageRefresh,
+            });
+        case "SEARCH_MY_FILE":
+            return Object.assign({}, state, {
+                contextOpen: false,
+                navigatorError: false,
+                navigatorLoading: true,
+            });
+        case "CHANGE_CONTEXT_MENU":
+            if (state.contextOpen && action.open) {
+                return Object.assign({}, state);
+            }
+            return Object.assign({}, state, {
+                contextOpen: action.open,
+                contextType: action.menuType,
+            });
+        case "SET_SUBTITLE":
+            return Object.assign({}, state, {
+                subTitle: action.title,
+            });
+        case "SET_SORT_METHOD":
+            return {
+                ...state,
+                sortMethod: action.method,
+            };
+        case "SET_NAVIGATOR":
+            return {
+                ...state,
+                contextOpen: false,
+                navigatorError: false,
+                navigatorLoading: action.navigatorLoading,
+            };
+        case "SET_OPTION_MODAL":
+            return Object.assign({}, state, {
+                modals: Object.assign({}, state.modals, {
+                    option: action.option,
+                }),
+                contextOpen: false,
+            });
+        case "OPEN_FILE_SELECTOR":
+            return {
+                ...state,
+                openFileSelector: state.openFileSelector + 1,
+                contextOpen: false,
+            };
+        case "OPEN_FOLDER_SELECTOR":
+            return {
+                ...state,
+                openFolderSelector: state.openFolderSelector + 1,
+                contextOpen: false,
+            };
+        case "SET_PAGINATION":
+            return {
+                ...state,
+                pagination: action.pagination,
+            };
+        case "SET_SHARE_INFO":
+            return {
+                ...state,
+                shareInfo: action.shareInfo,
+            };
+        default:
+            return state;
+    }
+};
+
+export default viewUpdate;