@danixl30/file-explorer-cli 1.0.0

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

@@ -0,0 +1,50 @@
+import { Alert, Spinner } from '@inkjs/ui';
+import { Box, Text } from 'ink';
+import React from 'react';
+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 { getNodeDetails } from '../implementation/node.details.js';
+import { nodeDetailLogic } from '../logic/node.detail.js';
+import { getNodeIcon } from '../utils/icon.parser.js';
+function formatBytes(bytes, decimals = 2) {
+    if (!+bytes)
+        return '0 Bytes';
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
+}
+export const NodeDetails = (props) => {
+    const details = nodeDetailLogic(props.node, nativeOnInitJob(useRefStateFactory(), useEffectStateObserver, useEffectOnInit), getNodeDetails());
+    if (details.error.value)
+        return React.createElement(Alert, { variant: "error" }, details.error.value.message);
+    if (details.isLoading.value || !details.data.value)
+        return (React.createElement(Box, { borderStyle: "single", width: "100%", alignItems: "stretch", flexDirection: "row" },
+            React.createElement(Spinner, { label: "Loading..." })));
+    return (React.createElement(Box, { borderStyle: "single", flexDirection: "column", width: "50%" },
+        React.createElement(Text, null, 'Path: ' + details.data.value.path),
+        React.createElement(Text, null, 'Name: ' +
+            getNodeIcon(details.data.value) +
+            details.data.value.name),
+        React.createElement(Text, null, 'Size: ' + formatBytes(details.data.value.size)),
+        details.data.value.createdDate && (React.createElement(Text, null, 'Created at: ' +
+            details.data.value.createdDate.toLocaleString())),
+        details.data.value.lastModifiedDate && (React.createElement(Text, null, 'Last modified: ' +
+            details.data.value.lastModifiedDate.toLocaleString())),
+        details.data.value.additionalData && (React.createElement(React.Fragment, null,
+            React.createElement(Text, null, 'Available: ' +
+                formatBytes(details.data.value.additionalData.available)),
+            React.createElement(Text, null, 'Used: ' +
+                formatBytes(details.data.value.additionalData.used)),
+            React.createElement(Text, null, 'Percent occupied: ' +
+                details.data.value.additionalData.percent),
+            React.createElement(Text, null, 'Partition schema: ' +
+                details.data.value.additionalData.partitionSchema),
+            React.createElement(Text, null, 'File system: ' +
+                details.data.value.additionalData.fileSystem),
+            React.createElement(Text, null, 'Device type: ' +
+                details.data.value.additionalData.deviceType)))));
+};

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

@@ -0,0 +1,61 @@
+import { Badge } from '@inkjs/ui';
+import { Box, Text } from 'ink';
+import React, { useEffect, useMemo, useState } from 'react';
+import { useResize } from '../hooks/useResize.js';
+import { getNodeIcon } from '../utils/icon.parser.js';
+const createRange = (start, end) => {
+    const arr = [];
+    for (let index = start; index <= end; index++)
+        arr.push(index);
+    return arr;
+};
+const calculatePercent = (nodes, index) => Math.round((index * 100) / nodes.length);
+export const NodeList = (props) => {
+    const { selections, nodes, index } = props;
+    const [lines, setLines] = useState(0);
+    const [[top, down], setSubIndexes] = useState([
+        -1,
+        lines - 2,
+    ]);
+    const [_columns, rows] = useResize();
+    useEffect(() => {
+        if (index === -1) {
+            setSubIndexes([-1, lines - 2]);
+            return;
+        }
+        if (index < top) {
+            setSubIndexes([index, index + lines - 1]);
+            return;
+        }
+        if (index > down) {
+            setSubIndexes([index - lines + 1, index]);
+            return;
+        }
+    }, [lines, props.index, nodes, top, down]);
+    useEffect(() => {
+        const lines = rows - 6 - (props.isTabs ? 3 : 0);
+        setLines(lines);
+        setSubIndexes([-1, lines - 2]);
+    }, [rows, props.isTabs]);
+    const range = useMemo(() => createRange(top, down), [top, down]);
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Box, { flexDirection: "column", height: "100%" },
+            top >= -1 && down <= lines - 2 && (React.createElement(Text, { backgroundColor: props.index === -1 ? 'blue' : undefined }, "..")),
+            props.nodes?.length > 0 &&
+                range.map((e) => {
+                    if (e === -1)
+                        return React.createElement(React.Fragment, null);
+                    const file = props.nodes[e];
+                    if (!file)
+                        return React.createElement(React.Fragment, null);
+                    return (React.createElement(React.Fragment, null,
+                        React.createElement(Text, { backgroundColor: index === e ? 'blue' : undefined }, `${selections.length > 0 &&
+                            selections.some((e) => e.path === file.path)
+                            ? ' '
+                            : selections.length > 0 &&
+                                selections.some((e) => e.path !== file.path)
+                                ? '󱗝 '
+                                : ''}${getNodeIcon(file)} ${file.name}`)));
+                })),
+        React.createElement(Badge, { color: "blueBright" }, calculatePercent(nodes ?? [], index + 1) + '%')));
+};

package/dist/file-display/events/node.written.js

@@ -0,0 +1,7 @@
+import { randomUUID } from 'node:crypto';
+export const createNodeWrittenEvent = () => ({
+    id: randomUUID(),
+    name: NODE_WRITTEN,
+    timestamp: new Date(),
+});
+export const NODE_WRITTEN = 'NODE_WRITTEN';

package/dist/file-display/hooks/useResize.js

@@ -0,0 +1,24 @@
+import { useStdout } from 'ink';
+import { useEffect, useState } from 'react';
+export const useResize = () => {
+    const { stdout } = useStdout();
+    const [size, setSize] = useState({
+        columns: stdout.columns,
+        rows: stdout.rows,
+    });
+    useEffect(() => {
+        function onResize() {
+            setSize({
+                columns: process.stdout.columns,
+                rows: process.stdout.rows,
+            });
+        }
+        process.stdout.on('resize', onResize);
+        process.stdout.write('\x1b[?1049h');
+        return () => {
+            process.stdout.off('resize', onResize);
+            process.stdout.write('\x1b[?1049l');
+        };
+    }, []);
+    return [size.columns, size.rows];
+};

package/dist/file-display/implementation/create.dir.js

@@ -0,0 +1,7 @@
+import { mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+export const createDirectory = async (path, dir) => {
+    mkdirSync(join(path, '/' + dir), {
+        recursive: true,
+    });
+};

package/dist/file-display/implementation/delete.js

@@ -0,0 +1,9 @@
+import { rmSync, unlinkSync } from 'node:fs';
+export const deleteNode = async (node) => {
+    if (node.type === 'FILE')
+        unlinkSync(node.path);
+    if (node.type === 'DIR')
+        rmSync(node.path, {
+            recursive: true,
+        });
+};

package/dist/file-display/implementation/execute.command.async.js

@@ -0,0 +1,6 @@
+import { exec } from 'node:child_process';
+export const executeCommandAsync = async (path, command) => {
+    exec(command, {
+        cwd: path,
+    });
+};

package/dist/file-display/implementation/execute.command.sync.js

@@ -0,0 +1,9 @@
+import { spawnSync } from 'node:child_process';
+export const executeCommandSync = async (path, command) => {
+    spawnSync(command, {
+        cwd: path,
+        stdio: 'inherit',
+        shell: true,
+    });
+    return 'Command executed';
+};

package/dist/file-display/implementation/execute.file.js

@@ -0,0 +1,4 @@
+import { exec } from 'node:child_process';
+export const executeFile = async (node) => {
+    exec(node.path);
+};

package/dist/file-display/implementation/filter.glob.js

@@ -0,0 +1,4 @@
+import { minimatch } from 'minimatch';
+export const filterByGlobPattern = (nodes, pattern) => nodes.filter((e) => minimatch(e.path, pattern, {
+    matchBase: true,
+}));

package/dist/file-display/implementation/get.all.files.js

@@ -0,0 +1,44 @@
+import { lstatSync, readdirSync } from 'node:fs';
+import { join, parse } from 'node:path';
+import { list } from 'drivelist';
+export const getAllFiles = async (path) => {
+    if (path === '/' && process.platform === 'win32') {
+        const drives = await list();
+        return drives
+            .map((e) => e.mountpoints.map((mout) => ({
+            path: mout.path.replace('\\', '/'),
+            name: `(${mout.path.replace('\\', '')}) ${e.description}`,
+            type: 'DRIVE',
+        })))
+            .flat();
+    }
+    const nodes = readdirSync(path);
+    return nodes
+        .map((e) => e.replaceAll('\\', '/'))
+        .map((node) => {
+        try {
+            const nodePath = join(path, node).replaceAll('\\', '/');
+            if (lstatSync(nodePath).isDirectory())
+                return {
+                    path: nodePath,
+                    type: 'DIR',
+                    name: parse(node).base,
+                };
+            return {
+                path: nodePath,
+                type: 'FILE',
+                name: parse(node).base,
+            };
+        }
+        catch (_e) {
+            return undefined;
+        }
+    })
+        .filter((e) => e != undefined)
+        .reduce((acc, e) => {
+        if (e.type === 'FILE')
+            return [acc[0], [...acc[1], e]];
+        return [[...acc[0], e], acc[1]];
+    }, [[], []])
+        .flat();
+};

package/dist/file-display/implementation/get.directory.js

@@ -0,0 +1,8 @@
+import { existsSync } from 'node:fs';
+export const getNextDir = async (node) => {
+    if (node.type === 'DRIVE')
+        return node.path;
+    if (!existsSync(node.path))
+        throw new Error('Directory not exist');
+    return node.path;
+};

package/dist/file-display/implementation/get.upper.directory.js

@@ -0,0 +1,17 @@
+import { existsSync } from 'node:fs';
+export const getUpperDirectory = async (path) => {
+    if (path === '/')
+        return path;
+    if (path.split('/').length === 2 &&
+        path.endsWith('/') &&
+        process.platform === 'win32')
+        return '/';
+    let pathToSearch = path.split('/').toSpliced(-1, 1).join('/');
+    if (process.platform === 'win32' && !path)
+        return '/';
+    if (pathToSearch.split('/').length === 1 && process.platform === 'win32')
+        pathToSearch = pathToSearch + '/';
+    if (!existsSync(pathToSearch))
+        return path;
+    return pathToSearch;
+};

package/dist/file-display/implementation/move.trash.js

@@ -0,0 +1,9 @@
+import { execSync } from 'node:child_process';
+import { resolve } from 'node:path';
+import trash from 'trash';
+export const moveNodeToTrash = async (node) => {
+    if (process.platform === 'win32')
+        execSync(`recycle -f ${resolve(node.path)}`);
+    else
+        await trash(node.path);
+};

package/dist/file-display/implementation/node.details.js

@@ -0,0 +1,79 @@
+import { statSync } from 'node:fs';
+import { readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { list } from 'drivelist';
+import { getDiskInfoSync } from 'node-disk-info';
+import { useEffect, useRef } from 'react';
+const dirSize = (isMounted) => {
+    const calculate = async (dir) => {
+        if (!isMounted.current)
+            throw new Error();
+        const files = await readdir(dir, { withFileTypes: true });
+        const paths = files.map(async (file) => {
+            const path = join(dir, file.name);
+            if (file.isDirectory())
+                return calculate(path);
+            if (file.isFile()) {
+                if (!isMounted.current)
+                    throw new Error();
+                const { size } = await stat(path);
+                return size;
+            }
+            return 0;
+        });
+        return (await Promise.all(paths))
+            .flat()
+            .reduce((acc, size) => acc + size, 0);
+    };
+    return calculate;
+};
+export const getNodeDetails = () => {
+    const isMounted = useRef(true);
+    useEffect(() => {
+        isMounted.current = true;
+        return () => {
+            isMounted.current = false;
+        };
+    }, []);
+    return async (node) => {
+        if (node.type === 'DRIVE') {
+            const drives = await list();
+            const infos = getDiskInfoSync();
+            const disk = drives.find((e) => e.mountpoints.some((e) => e.path.replaceAll('\\', '/') === node.path));
+            if (!disk)
+                throw new Error('Disk not exist');
+            const info = infos.find((e) => node.path.startsWith(e.mounted));
+            if (!info)
+                throw new Error('Not disk info');
+            return {
+                ...node,
+                size: disk.size ?? info.blocks,
+                additionalData: {
+                    used: info.used,
+                    percent: info.capacity,
+                    fileSystem: info.filesystem,
+                    available: info.available,
+                    partitionSchema: disk.partitionTableType?.toUpperCase() ?? 'No schema',
+                    deviceType: disk.isCard
+                        ? 'CARD'
+                        : disk.isUSB
+                            ? 'USB'
+                            : disk.isSCSI
+                                ? 'SCSI'
+                                : disk.isVirtual
+                                    ? 'VIRTUAL'
+                                    : 'REMOVABLE',
+                },
+            };
+        }
+        const stats = statSync(node.path);
+        return {
+            ...node,
+            size: node.type === 'FILE'
+                ? stats.size
+                : await dirSize(isMounted)(node.path),
+            createdDate: stats.birthtime,
+            lastModifiedDate: stats.mtime,
+        };
+    };
+};

package/dist/file-display/implementation/paste.operation.js

@@ -0,0 +1,40 @@
+import { copyFileSync, cpSync, existsSync, lstatSync, renameSync, } from 'node:fs';
+import { join, parse } from 'node:path';
+const generateFilename = (data, path) => {
+    const name = parse(data.path);
+    const numberGenerator = (index = 1) => {
+        if (data.type === 'FILE') {
+            if (existsSync(join(path, name.name + ` (${index})` + name.ext)))
+                return numberGenerator(++index);
+            return name.name + ` (${index})` + name.ext;
+        }
+        if (existsSync(join(path, name.base + ` (${index})`)))
+            return numberGenerator(++index);
+        return name.base + ` (${index})`;
+    };
+    if (existsSync(join(path, name.base)))
+        return numberGenerator();
+    return name.base;
+};
+const pasteWorker = (data, destinate, operation, replace) => {
+    const filename = replace
+        ? parse(data.path).base
+        : generateFilename(data, destinate);
+    if (operation === 'CUT') {
+        renameSync(data.path, join(destinate, `/${filename}`));
+    }
+    if (operation === 'COPY' && data.type === 'FILE') {
+        copyFileSync(data.path, join(destinate, `/${filename}`));
+    }
+    if (operation === 'COPY' && data.type === 'DIR') {
+        cpSync(data.path, join(destinate, `/${filename}`), {
+            recursive: true,
+            force: true,
+        });
+    }
+};
+export const pasteOperation = async (data, destinate, replace) => {
+    if (!lstatSync(destinate).isDirectory())
+        throw new Error('The destinate must be a directory');
+    data.items.map((node) => pasteWorker(node, destinate, data.opeation, replace));
+};

package/dist/file-display/implementation/rename.js

@@ -0,0 +1,6 @@
+import { renameSync } from 'node:fs';
+import { join } from 'node:path';
+export const renameNode = async (node, newName) => {
+    const basePath = node.path.split('/').toSpliced(-1, 1).join('/');
+    renameSync(node.path, join(basePath, `/${newName}`));
+};

package/dist/file-display/logic/file.manager.js

@@ -0,0 +1,107 @@
+import { createUpdateTabSelectionEvent } from '../../tabs/events/update.tab.selection.js';
+export const fileManagerLogic = (stateProvider, stateObserver, eventHandler, onInitJob, path, getAllFiles, uppderDir, nextDir, executeFile, history, selection, filterByGlobPattern) => {
+    const pathState = stateProvider(path);
+    const selectionsState = stateProvider(selection);
+    const selectedNode = stateProvider(undefined);
+    const filePaginated = onInitJob(() => getAllFiles(pathState.state.value), pathState.state);
+    const toggleSelected = (node) => {
+        if (selectionsState.state.value.some((e) => e.path === node.path))
+            selectionsState.setState(selectionsState.state.value.filter((e) => e.path !== node.path));
+        else
+            selectionsState.setState([...selectionsState.state.value, node]);
+    };
+    const inevertSelection = () => {
+        selectionsState.setState(filePaginated.data.value.filter((e) => !selectionsState.state.value.some((node) => e.path === node.path) && e.type !== 'DRIVE'));
+    };
+    const selectAll = () => {
+        selectionsState.setState(filePaginated.data.value.filter((e) => e.type !== 'DRIVE'));
+    };
+    const unSelectAll = () => {
+        selectionsState.setState([]);
+    };
+    const selectNode = async (node) => {
+        if (filePaginated.isLoading.value || filePaginated.isReloading.value)
+            return;
+        if (node.type === 'DIR' || node.type === 'DRIVE') {
+            const nextPath = await nextDir(node);
+            const prevPath = pathState.state.value;
+            pathState.setState(nextPath);
+            history.push(nextPath, prevPath);
+            return;
+        }
+        await executeFile(node);
+    };
+    const gotToUpper = async () => {
+        if (filePaginated.isLoading.value)
+            return;
+        const nextPath = await uppderDir(pathState.state.value);
+        if (!nextPath)
+            return;
+        const prevPath = pathState.state.value;
+        pathState.setState(nextPath);
+        history.push(pathState.state.value, prevPath);
+    };
+    const popHistory = () => {
+        if (filePaginated.isLoading.value)
+            return;
+        const nextPath = history.pop(pathState.state.value);
+        if (!nextPath)
+            return;
+        pathState.setState(nextPath);
+    };
+    const forwardHistory = () => {
+        if (filePaginated.isLoading.value)
+            return;
+        const nextPath = history.forward(pathState.state.value);
+        if (!nextPath)
+            return;
+        pathState.setState(nextPath);
+    };
+    const refresh = () => filePaginated.reload();
+    const selectNodeToDetails = (node) => {
+        selectedNode.setState(node);
+    };
+    const cleanNodeSelected = () => {
+        selectedNode.setState(undefined);
+    };
+    const navigateTo = (path) => {
+        const prevPath = pathState.state.value;
+        pathState.setState(path);
+        history.push(pathState.state.value, prevPath);
+    };
+    const selectByGlobPattern = (pattern) => {
+        selectionsState.setState(filterByGlobPattern(filePaginated.data.value.filter((e) => e.type !== 'DRIVE'), pattern));
+    };
+    stateObserver(() => {
+        if (!filePaginated.data.value)
+            return;
+        selectionsState.setState(selectionsState.state.value.filter((e) => filePaginated.data.value.some((node) => e.path === node.path)));
+    }, filePaginated.data);
+    stateObserver(() => {
+        selectionsState.setState([]);
+    }, pathState.state);
+    stateObserver(() => {
+        eventHandler.publish(createUpdateTabSelectionEvent(selectionsState.state.value));
+    }, selectionsState.state);
+    return {
+        files: filePaginated.data,
+        isLoading: filePaginated.isLoading,
+        isError: filePaginated.error,
+        forwardHistory,
+        popHistory,
+        selectNode,
+        refresh,
+        path: pathState.state,
+        gotToUpper,
+        selections: selectionsState.state,
+        toggleSelected,
+        selectAll,
+        inevertSelection,
+        unSelectAll,
+        selectedNode: selectedNode.state,
+        selectNodeToDetails,
+        navigateTo,
+        cleanNodeSelected,
+        selectByGlobPattern,
+    };
+};

package/dist/file-display/logic/history.manager.js

@@ -0,0 +1,47 @@
+import { createUpdateTabDataEvent } from '../../tabs/events/update.tab.data.js';
+export const historyManager = (valueProvider, eventHandler, historyInitial) => {
+    const backHitory = valueProvider(historyInitial.previous);
+    const forwardHistory = valueProvider(historyInitial.forward);
+    const push = (path, currentPath) => {
+        backHitory.value.push(currentPath);
+        forwardHistory.value = [];
+        eventHandler.publish(createUpdateTabDataEvent({
+            path: path,
+            history: {
+                previous: backHitory.value,
+                forward: forwardHistory.value,
+            },
+        }));
+    };
+    const pop = (currentPath) => {
+        const path = backHitory.value.pop();
+        if (path)
+            forwardHistory.value.push(currentPath);
+        eventHandler.publish(createUpdateTabDataEvent({
+            path: path ?? currentPath,
+            history: {
+                previous: backHitory.value,
+                forward: forwardHistory.value,
+            },
+        }));
+        return path;
+    };
+    const forward = (currentPath) => {
+        const path = forwardHistory.value.pop();
+        if (path)
+            backHitory.value.push(currentPath);
+        eventHandler.publish(createUpdateTabDataEvent({
+            path: path ?? currentPath,
+            history: {
+                previous: backHitory.value,
+                forward: forwardHistory.value,
+            },
+        }));
+        return path;
+    };
+    return {
+        push,
+        pop,
+        forward,
+    };
+};

package/dist/file-display/logic/node.detail.js

@@ -0,0 +1,8 @@
+export const nodeDetailLogic = (node, onInitJob, getNodeDetails) => {
+    const detailsJob = onInitJob(() => getNodeDetails(node));
+    return {
+        data: detailsJob.data,
+        isLoading: detailsJob.isLoading,
+        error: detailsJob.error,
+    };
+};