@danixl30/file-explorer-cli 1.0.0

package/dist/core/infraestructure/on-init-job/nativeOnInitJobLazy.js

@@ -0,0 +1,32 @@
+export const nativeOnInitJob = (stateFactory) => (callback, onTask) => {
+    const dataState = stateFactory(null);
+    const loadingState = stateFactory(false);
+    const errorState = stateFactory(null);
+    const doJob = async (...args) => {
+        if (loadingState.state)
+            throw new Error('Is in job');
+        dataState.setState(null);
+        errorState.setState(null);
+        loadingState.setState(true);
+        const loadingTask = onTask?.();
+        try {
+            const res = await callback(...args);
+            dataState.setState(res);
+            loadingState.setState(false);
+            loadingTask?.success?.();
+            return res;
+        }
+        catch (e) {
+            errorState.setState(e);
+            loadingTask?.error?.(e);
+            loadingState.setState(false);
+            throw e;
+        }
+    };
+    return {
+        do: doJob,
+        data: dataState.state,
+        error: errorState.state,
+        isLoading: loadingState.state,
+    };
+};

package/dist/core/infraestructure/pagination-manager/data-transforms/infinite.js

@@ -0,0 +1 @@
+export const infiniteDataTransform = () => (res, prev) => [...prev, ...res];

package/dist/core/infraestructure/pagination-manager/data-transforms/normal.js

@@ -0,0 +1 @@
+export const normalDataTransform = () => (res, _prev) => res;

package/dist/core/infraestructure/pagination-manager/usePaginationManager.js

@@ -0,0 +1,59 @@
+import { normalDataTransform } from './data-transforms/normal.js';
+export const usePaginationManager = (stateFactory, stateObserver, onInit) => (callback, dataTransform = normalDataTransform()) => {
+    const pageState = stateFactory(1);
+    const dataState = stateFactory([]);
+    const errorState = stateFactory(null);
+    const loadingState = stateFactory(false);
+    const isTopState = stateFactory(false);
+    const job = async () => {
+        if (loadingState.state.value)
+            return;
+        loadingState.setState(true);
+        errorState.setState(null);
+        try {
+            const data = await callback(pageState.state.value);
+            if (data.length === 0)
+                isTopState.setState(true);
+            dataState.setState(dataTransform(data, dataState.state.value));
+        }
+        catch (e) {
+            errorState.setState(e);
+        }
+        loadingState.setState(false);
+    };
+    onInit(() => {
+        job();
+    });
+    stateObserver(() => {
+        job();
+    }, pageState.state);
+    const increment = () => pageState.setState(pageState.state.value + 1);
+    const reset = () => {
+        isTopState.setState(false);
+        dataState.setState([]);
+        pageState.setState(1);
+        job();
+    };
+    const previousPage = () => {
+        isTopState.setState(false);
+        if (pageState.state.value > 2)
+            pageState.setState(pageState.state.value - 1);
+    };
+    const setPage = (page) => {
+        isTopState.setState(false);
+        if (page < 1 || Math.ceil(page) !== page)
+            throw new Error('Invalid page');
+        pageState.setState(page);
+    };
+    return {
+        data: dataState.state,
+        error: errorState.state,
+        isLoading: loadingState.state,
+        increment,
+        reset,
+        page: pageState.state,
+        previousPage,
+        setPage,
+        isTop: isTopState.state,
+    };
+};

package/dist/core/infraestructure/state/useRefStateProvider.js

@@ -0,0 +1,39 @@
+import { useEffect, useRef, useState } from 'react';
+export const useRefStateFactory = () => {
+    const [_, forceUpdate] = useState(0);
+    const isMounted = useRef(true);
+    useEffect(() => {
+        isMounted.current = true;
+        return () => {
+            isMounted.current = false;
+        };
+    }, []);
+    return (initialize) => {
+        const subscriptors = useRef([]);
+        const firstTime = useRef(true);
+        const state = useRef(initialize);
+        useEffect(() => {
+            if (firstTime.current) {
+                firstTime.current = false;
+                return;
+            }
+            subscriptors.current.forEach((e) => e(state.current));
+        }, [state]);
+        return {
+            state: {
+                get value() {
+                    return state.current;
+                },
+                subscribe(callback) {
+                    subscriptors.current.push(callback);
+                },
+            },
+            setState(value) {
+                if (!isMounted.current)
+                    return;
+                state.current = value;
+                forceUpdate((value) => ++value);
+            },
+        };
+    };
+};

package/dist/core/infraestructure/state/useStateProvider.js

@@ -0,0 +1,35 @@
+import { useEffect, useRef, useState } from 'react';
+export const useStateFactory = (initialize) => {
+    const subscriptors = useRef([]);
+    const firstTime = useRef(true);
+    const isMounted = useRef(true);
+    const [state, setState] = useState(initialize);
+    useEffect(() => {
+        if (firstTime.current) {
+            firstTime.current = false;
+            return;
+        }
+        subscriptors.current.forEach((e) => e(state));
+    }, [state]);
+    useEffect(() => {
+        isMounted.current = true;
+        return () => {
+            isMounted.current = false;
+        };
+    }, []);
+    return {
+        state: {
+            get value() {
+                return state;
+            },
+            subscribe(callback) {
+                subscriptors.current.push(callback);
+            },
+        },
+        setState(value) {
+            if (!isMounted.current)
+                return;
+            setState(value);
+        },
+    };
+};

package/dist/core/infraestructure/state-observer/useEffectStateObserver.js

@@ -0,0 +1,16 @@
+import { useEffect, useRef } from 'react';
+export const useEffectStateObserver = (callback, ...states) => {
+    if (states.length === 0)
+        return;
+    const firstTime = useRef(true);
+    useEffect(() => {
+        if (firstTime.current) {
+            firstTime.current = false;
+            return;
+        }
+        const res = callback();
+        return () => {
+            res?.();
+        };
+    }, [...states.map((e) => e.value)]);
+};

package/dist/core/infraestructure/timer/sleep.js

@@ -0,0 +1,2 @@
+import { setTimeout } from 'node:timers/promises';
+export const setTimeoutSleep = (time) => setTimeout(time);

package/dist/core/infraestructure/uuid/uuid.generator.js

@@ -0,0 +1,2 @@
+import { randomUUID } from 'node:crypto';
+export const uuidGenerator = () => randomUUID();

package/dist/core/infraestructure/value-provider/useRefValueProvider.js

@@ -0,0 +1,12 @@
+import { useRef } from 'react';
+export const useRefValueProvider = () => (initialValue) => {
+    const ref = useRef(initialValue);
+    return {
+        get value() {
+            return ref.current;
+        },
+        set value(value) {
+            ref.current = value;
+        },
+    };
+};

package/dist/core/utils/argument.type.js

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

package/dist/core/utils/optional.js

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

package/dist/file-display/FileDisplay.js

@@ -0,0 +1,456 @@
+import { existsSync } from 'node:fs';
+import clipboardy from 'clipboardy';
+import { Box, Text, useInput } from 'ink';
+import React, { useContext, useRef, useState } from 'react';
+import { AlertContext } from '../alerts/AlertContextProvider.js';
+import { BookmarkPaneContext } from '../bookmark/context/BookmarkPaneContext.js';
+import { createAddBookmarkItem } from '../bookmark/events/add.item.js';
+import { ClipboardContext } from '../clipboard/ClipboardProvider.js';
+import { EventContext } from '../core/infraestructure/event-handler/context/EventProvider.js';
+import { nativeOnInitJob } from '../core/infraestructure/on-init-job/nativeOnInitJob.js';
+import { useEffectOnInit } from '../core/infraestructure/on-init/useEffectOnInit.js';
+import { useEffectStateObserver } from '../core/infraestructure/state-observer/useEffectStateObserver.js';
+import { useRefStateFactory } from '../core/infraestructure/state/useRefStateProvider.js';
+import { useRefValueProvider } from '../core/infraestructure/value-provider/useRefValueProvider.js';
+import { InputContextCapture } from '../input-capture/InputContextCapture.js';
+import { TabsContext } from '../tabs/TabsContext.js';
+import { TextFieldContextCapture } from '../text-field/TextFieldCaptureContext.js';
+import { NodeDetails } from './components/NodeDetails.js';
+import { NodeList } from './components/NodeList.js';
+import { createNodeWrittenEvent } from './events/node.written.js';
+import { createDirectory } from './implementation/create.dir.js';
+import { deleteNode } from './implementation/delete.js';
+import { executeCommandAsync } from './implementation/execute.command.async.js';
+import { executeCommandSync } from './implementation/execute.command.sync.js';
+import { executeFile } from './implementation/execute.file.js';
+import { filterByGlobPattern } from './implementation/filter.glob.js';
+import { getAllFiles } from './implementation/get.all.files.js';
+import { getNextDir } from './implementation/get.directory.js';
+import { getUpperDirectory } from './implementation/get.upper.directory.js';
+import { moveNodeToTrash } from './implementation/move.trash.js';
+import { pasteOperation } from './implementation/paste.operation.js';
+import { renameNode } from './implementation/rename.js';
+import { fileManagerLogic } from './logic/file.manager.js';
+import { historyManager } from './logic/history.manager.js';
+import { operationsManager } from './logic/operations.manager.js';
+export default function FileDisplay(props) {
+    const isInputEnable = useRef(true);
+    const stateFactory = useRefStateFactory();
+    const tabs = useContext(TabsContext);
+    const alert = useContext(AlertContext);
+    const inputCapture = useContext(InputContextCapture);
+    const [index, setIndex] = useState(-1);
+    const clipboard = useContext(ClipboardContext);
+    const textField = useContext(TextFieldContextCapture);
+    const eventHandler = useContext(EventContext);
+    const { isBookmarkEnabled } = useContext(BookmarkPaneContext);
+    const history = historyManager(useRefValueProvider(), eventHandler, props.initialData.history);
+    const files = fileManagerLogic(stateFactory, useEffectStateObserver, eventHandler, nativeOnInitJob(stateFactory, useEffectStateObserver, useEffectOnInit), props.initialData.path, getAllFiles, getUpperDirectory, getNextDir, executeFile, history, props.selection, filterByGlobPattern);
+    const operations = operationsManager(files, clipboard, pasteOperation, deleteNode, renameNode, createDirectory, executeCommandSync, executeCommandAsync, moveNodeToTrash);
+    const filesList = files.files.value ?? [];
+    const moveUpArrow = () => {
+        setIndex((prev) => {
+            if (prev <= -1)
+                return prev;
+            return prev - 1;
+        });
+    };
+    const moveDownArrow = () => {
+        setIndex((prev) => {
+            if (!filesList.length)
+                return -1;
+            if (prev + 1 >= filesList.length)
+                return filesList.length - 1;
+            return prev + 1;
+        });
+    };
+    const setCut = () => {
+        if (index < 0 || index >= filesList.length)
+            return;
+        if (filesList[index]?.type === 'DRIVE')
+            return;
+        operations.cut(filesList[index]);
+        alert.setAlert({
+            kind: 'INFO',
+            message: 'File added to clipboard to cut',
+        });
+    };
+    const setCopy = () => {
+        if (index < 0 || index >= filesList.length)
+            return;
+        if (filesList[index]?.type === 'DRIVE')
+            return;
+        operations.copy(filesList[index]);
+        alert.setAlert({
+            kind: 'INFO',
+            message: 'File added to clipboard to copy',
+        });
+    };
+    const executePaste = async (force) => {
+        if (!clipboard.item.value)
+            return;
+        isInputEnable.current = false;
+        alert.alertControlled({
+            kind: 'INFO',
+            message: clipboard.item.value.opeation === 'COPY'
+                ? 'Coping item...'
+                : 'Cutting item...',
+        });
+        try {
+            await operations.paste(force);
+            alert.setAlert({
+                message: 'Paste successfull',
+                kind: 'SUCCESS',
+            });
+            eventHandler.publish(createNodeWrittenEvent());
+        }
+        catch (error) {
+            alert.setAlert({
+                kind: 'ERR',
+                message: error.message,
+            });
+        }
+        isInputEnable.current = true;
+    };
+    const openDirInNewTab = () => {
+        if (index < 0 || index >= filesList.length)
+            return;
+        const node = filesList[index];
+        if (node.type === 'FILE')
+            return;
+        tabs.addTab({
+            path: node.path,
+            history: {
+                forward: [],
+                previous: [],
+            },
+        });
+    };
+    const selectItem = () => {
+        if (index === -1)
+            files.gotToUpper();
+        else if (filesList[index])
+            files.selectNode(filesList[index]);
+    };
+    const deleteItem = () => {
+        if (index < 0 || index >= filesList.length)
+            return;
+        const node = filesList[index];
+        if (node.type === 'DRIVE')
+            return;
+        inputCapture.addCallback(async (key) => {
+            if (key !== 'Y')
+                return;
+            isInputEnable.current = false;
+            alert.alertControlled({
+                kind: 'INFO',
+                message: 'Deleting item...',
+            });
+            try {
+                await operations.removeNode(node);
+                alert.setAlert({
+                    message: 'Delete successfull',
+                    kind: 'SUCCESS',
+                });
+                eventHandler.publish(createNodeWrittenEvent());
+            }
+            catch (error) {
+                alert.setAlert({
+                    kind: 'ERR',
+                    message: error.message,
+                });
+            }
+            isInputEnable.current = true;
+        }, 'Do you want to remove this item? Y/n');
+    };
+    const createDir = () => {
+        if (filesList.some((e) => e.type === 'DRIVE'))
+            return;
+        textField.addCallback({
+            placeHolder: 'Set folder name',
+            callback: {
+                onSuccess: async (data) => {
+                    if (!data)
+                        return;
+                    try {
+                        await operations.createDirectory(data);
+                        alert.setAlert({
+                            message: 'Folder created',
+                            kind: 'SUCCESS',
+                        });
+                    }
+                    catch (error) {
+                        alert.setAlert({
+                            kind: 'ERR',
+                            message: error.message,
+                        });
+                    }
+                },
+                onChange: (data) => {
+                    if (!data ||
+                        files.files.value?.some((e) => e.name === data))
+                        textField.setError('Element already exist');
+                    else
+                        textField.setError('');
+                },
+            },
+        });
+    };
+    const renameItem = () => {
+        if (index < 0 || index >= filesList.length || selections.length)
+            return;
+        const node = filesList[index];
+        if (node.type === 'DRIVE')
+            return;
+        textField.addCallback({
+            placeHolder: 'Set item name',
+            defaultValue: node.name,
+            text: 'Rename item name',
+            callback: {
+                onSuccess: async (data) => {
+                    if (!data)
+                        return;
+                    try {
+                        await operations.rename(node, data);
+                        alert.setAlert({
+                            message: 'Item renamed',
+                            kind: 'SUCCESS',
+                        });
+                        eventHandler.publish(createNodeWrittenEvent());
+                    }
+                    catch (error) {
+                        alert.setAlert({
+                            kind: 'ERR',
+                            message: error.message,
+                        });
+                    }
+                },
+                onChange: (data) => {
+                    if (!data ||
+                        (data !== node.name &&
+                            files.files.value?.some((e) => e.name === data)))
+                        textField.setError('Element already exist');
+                    else
+                        textField.setError('');
+                },
+            },
+        });
+    };
+    const toggleSelectItem = () => {
+        if (index < 0 || index >= filesList.length)
+            return;
+        const node = filesList[index];
+        if (node.type === 'DRIVE')
+            return;
+        files.toggleSelected(node);
+    };
+    const selectToDetails = () => {
+        if (index < 0 || index >= filesList.length)
+            return;
+        const node = filesList[index];
+        files.selectNodeToDetails(node);
+    };
+    const addToBookmark = () => {
+        if (index < 0 || index >= filesList.length)
+            return;
+        const node = filesList[index];
+        if (node.type === 'FILE')
+            return;
+        eventHandler.publish(createAddBookmarkItem(node));
+    };
+    const copyNodePathToClipboard = () => {
+        if (index < 0 || index >= filesList.length)
+            return;
+        const node = filesList[index];
+        clipboardy.writeSync(node.path);
+        alert.setAlert({
+            kind: 'INFO',
+            message: 'Item path added to clipboard',
+        });
+    };
+    const copyPathToClipboard = () => {
+        clipboardy.writeSync(files.path.value);
+        alert.setAlert({
+            kind: 'INFO',
+            message: 'Current dir path added to clipboard',
+        });
+    };
+    const runCommandAsync = () => {
+        textField.addCallback({
+            placeHolder: 'Command in background...',
+            callback: {
+                onSuccess: async (command) => {
+                    await operations.runCommandAsync(command);
+                },
+                onChange: async () => { },
+            },
+        });
+    };
+    const runCommandSync = () => {
+        textField.addCallback({
+            placeHolder: 'Command blocking...',
+            callback: {
+                onSuccess: async (command) => {
+                    isInputEnable.current = false;
+                    await operations
+                        .runCommandSync(command)
+                        .then((data) => alert.setAlert({
+                        kind: 'INFO',
+                        message: data,
+                    }))
+                        .catch((err) => alert.setAlert({
+                        kind: 'ERR',
+                        message: err.message,
+                    }));
+                    isInputEnable.current = true;
+                },
+                onChange: async () => { },
+            },
+        });
+    };
+    const setPath = () => {
+        textField.addCallback({
+            placeHolder: 'Set path',
+            defaultValue: files.path.value,
+            text: 'Navigate to path',
+            callback: {
+                onSuccess: async (data) => {
+                    if (!data)
+                        return;
+                    files.navigateTo(data);
+                },
+                onChange: (data) => {
+                    if (!existsSync(data))
+                        textField.setError('Path not exist');
+                    else
+                        textField.setError('');
+                },
+            },
+        });
+    };
+    const moveItemToTrash = () => {
+        if (index < 0 || index >= filesList.length)
+            return;
+        const node = filesList[index];
+        if (node.type === 'DRIVE')
+            return;
+        inputCapture.addCallback(async (key) => {
+            if (key !== 'y')
+                return;
+            isInputEnable.current = false;
+            alert.alertControlled({
+                kind: 'INFO',
+                message: 'Moving item to trash...',
+            });
+            try {
+                await operations.removeNode(node);
+                alert.setAlert({
+                    message: 'Moved successfull',
+                    kind: 'SUCCESS',
+                });
+                eventHandler.publish(createNodeWrittenEvent());
+            }
+            catch (error) {
+                alert.setAlert({
+                    kind: 'ERR',
+                    message: error.message,
+                });
+            }
+            isInputEnable.current = true;
+        }, 'Do you want to move this item to trash? Y/n');
+    };
+    const setGlobPattern = () => {
+        if (filesList.some((e) => e.type === 'DRIVE'))
+            return;
+        textField.addCallback({
+            placeHolder: 'Add glob pattern to search...',
+            callback: {
+                onChange() { },
+                onSuccess(data) {
+                    files.selectByGlobPattern(data);
+                },
+            },
+        });
+    };
+    useInput((input, key) => {
+        if (!isInputEnable.current ||
+            inputCapture.isInputEnabled ||
+            textField.isInputEnabled ||
+            isBookmarkEnabled)
+            return;
+        if (key.ctrl && key.upArrow)
+            files.gotToUpper();
+        else if (key.ctrl && key.leftArrow)
+            files.popHistory();
+        else if (key.ctrl && key.rightArrow)
+            files.forwardHistory();
+        else if (key.upArrow)
+            moveUpArrow();
+        else if (key.downArrow)
+            moveDownArrow();
+        else if (key.ctrl && input === 'd')
+            files.cleanNodeSelected();
+        else if (input === 'S' && key.shift)
+            addToBookmark();
+        else if (input === 'i')
+            selectToDetails();
+        else if (input === 'a')
+            createDir();
+        else if (input === 'l' && key.ctrl)
+            setPath();
+        else if (input === 'R' && key.shift)
+            renameItem();
+        else if (input === 'd')
+            moveItemToTrash();
+        else if (input === 'D' && key.shift)
+            deleteItem();
+        else if (input === 'p')
+            executePaste(false);
+        else if (input === 'P' && key.shift)
+            executePaste(true);
+        else if (key.shift && input === 'T')
+            openDirInNewTab();
+        else if (input === 'C' && key.shift)
+            setCut();
+        else if (input === 'c')
+            setCopy();
+        else if (input === 'r')
+            files.refresh();
+        else if (key.shift && key.rightArrow)
+            files.unSelectAll();
+        else if (key.rightArrow)
+            toggleSelectItem();
+        else if (key.shift && input === 'A')
+            files.selectAll();
+        else if (key.shift && input === 'I')
+            files.inevertSelection();
+        else if (key.return)
+            selectItem();
+        else if (key.escape)
+            clipboard.removeItem();
+        else if (input === ';')
+            runCommandAsync();
+        else if (input === ':')
+            runCommandSync();
+        else if (input === 'y')
+            copyNodePathToClipboard();
+        else if (input === 'Y' && key.shift)
+            copyPathToClipboard();
+        else if (input === 'g')
+            setGlobPattern();
+    });
+    if (files.isLoading.value)
+        return (React.createElement(Box, { width: "100%", alignItems: "center" },
+            React.createElement(Text, null, "Loading...")));
+    if (files.isError.value)
+        return (React.createElement(Box, { width: "100%", alignItems: "center" },
+            React.createElement(Text, null, files.isError.value.message)));
+    const selections = files.selections.value;
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Box, { height: "100%", flexDirection: "row", borderStyle: "round" },
+            React.createElement(Box, { overflowY: "hidden", flexDirection: "column", width: "100%", height: "100%" },
+                React.createElement(Box, { width: "100%", borderStyle: "double" },
+                    React.createElement(Text, null, files.path.value)),
+                React.createElement(NodeList, { nodes: files.files.value, index: index, isTabs: tabs.tabs.value.length > 1, selections: files.selections.value })),
+            files.selectedNode.value && (React.createElement(NodeDetails, { node: files.selectedNode.value })))));
+}

package/dist/file-display/components/Loading.js

@@ -0,0 +1,4 @@
+import React from 'react';
+export const Loading = (props) => {
+    return React.createElement(React.Fragment, null, props.isloading ? props.fallback : props.children);
+};