@danixl30/file-explorer-cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 danixl30
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/alerts/AlertContextProvider.js

@@ -0,0 +1,13 @@
+import React, { createContext } from 'react';
+import { timerManager } from '../core/application/timer/timer.js';
+import { useEffectStateObserver } from '../core/infraestructure/state-observer/useEffectStateObserver.js';
+import { useRefStateFactory } from '../core/infraestructure/state/useRefStateProvider.js';
+import { setTimeoutSleep } from '../core/infraestructure/timer/sleep.js';
+import { useRefValueProvider } from '../core/infraestructure/value-provider/useRefValueProvider.js';
+import { alertLogic } from './logic/alert.logic.js';
+export const AlertContext = createContext(undefined);
+export const AlertContextProvider = (props) => {
+    const stateFactory = useRefStateFactory();
+    const data = alertLogic(stateFactory, timerManager(stateFactory, useRefValueProvider(), useEffectStateObserver, props.time || 2000, setTimeoutSleep));
+    return (React.createElement(AlertContext.Provider, { value: data }, props.children));
+};

package/dist/alerts/components/AlertDisplay.js

@@ -0,0 +1,19 @@
+import { Alert, Badge } from '@inkjs/ui';
+import { Box } from 'ink';
+import React, { useContext } from 'react';
+import { ClipboardContext } from '../../clipboard/ClipboardProvider.js';
+import { AlertContext } from '../AlertContextProvider.js';
+export const AlertDisplay = () => {
+    const alert = useContext(AlertContext);
+    const clipboard = useContext(ClipboardContext);
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Box, { width: "100%", flexDirection: "column" },
+            clipboard.item.value && (React.createElement(Box, null,
+                React.createElement(Badge, { color: "blue" },
+                    clipboard.item.value.items.length,
+                    " items in clipboard"))),
+            alert.alert.value?.kind === 'ERR' && (React.createElement(Alert, { variant: "error" }, alert.alert.value.message)),
+            alert.alert.value?.kind === 'WARN' && (React.createElement(Alert, { variant: "warning" }, alert.alert.value.message)),
+            alert.alert.value?.kind === 'INFO' && (React.createElement(Alert, { variant: "info" }, alert.alert.value.message)),
+            alert.alert.value?.kind === 'SUCCESS' && (React.createElement(Alert, { variant: "success" }, alert.alert.value.message)))));
+};

package/dist/alerts/logic/alert.logic.js

@@ -0,0 +1,16 @@
+export const alertLogic = (stateFactory, timer) => {
+    const alertState = stateFactory(undefined);
+    const setAlert = (alert) => {
+        alertState.setState(alert);
+        timer(() => alertState.setState(undefined));
+    };
+    const alertControlled = (alert) => {
+        alertState.setState(alert);
+        return () => alertState.setState(undefined);
+    };
+    return {
+        alert: alertState.state,
+        alertControlled,
+        setAlert,
+    };
+};

package/dist/app.js

@@ -0,0 +1,27 @@
+import { Box } from 'ink';
+import React from 'react';
+import { AlertContextProvider } from './alerts/AlertContextProvider.js';
+import { AlertDisplay } from './alerts/components/AlertDisplay.js';
+import { BookmarkPaneContextProvider } from './bookmark/context/BookmarkPaneContext.js';
+import { ClipboardProvider } from './clipboard/ClipboardProvider.js';
+import { EventProvider } from './core/infraestructure/event-handler/context/EventProvider.js';
+import { InputCaptureWarpper } from './input-capture/InputCapureWrapper.js';
+import { InputContextCaptureProvider } from './input-capture/InputContextCapture.js';
+import { TabsContextProvider } from './tabs/TabsContext.js';
+import TabsWrapper from './tabs/wrapper/tabs.wrapper.js';
+import { TextFieldContextCaptureProvider } from './text-field/TextFieldCaptureContext.js';
+import { TextFieldWrapper } from './text-field/TextFieldWrapper.js';
+export default function App(props) {
+    return (React.createElement(Box, { height: "100%", width: "100%", flexDirection: "column" },
+        React.createElement(EventProvider, null,
+            React.createElement(TextFieldContextCaptureProvider, null,
+                React.createElement(InputContextCaptureProvider, null,
+                    React.createElement(AlertContextProvider, null,
+                        React.createElement(ClipboardProvider, null,
+                            React.createElement(BookmarkPaneContextProvider, null,
+                                React.createElement(TabsContextProvider, { defaultPath: props.defaultPath },
+                                    React.createElement(TabsWrapper, null),
+                                    React.createElement(AlertDisplay, null),
+                                    React.createElement(InputCaptureWarpper, null),
+                                    React.createElement(TextFieldWrapper, null))))))))));
+}

package/dist/bookmark/Bookmark.js

@@ -0,0 +1,123 @@
+import { Box, Text, useInput } from 'ink';
+import React, { useContext, useState } from 'react';
+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 { NODE_WRITTEN } from '../file-display/events/node.written.js';
+import { InputContextCapture } from '../input-capture/InputContextCapture.js';
+import { TabsContext } from '../tabs/TabsContext.js';
+import { TextFieldContextCapture } from '../text-field/TextFieldCaptureContext.js';
+import { BookmarkList } from './components/BookmarkList.js';
+import { BookmarkPaneContext } from './context/BookmarkPaneContext.js';
+import { ADD_BOOKMARK_ITEM } from './events/add.item.js';
+import { cleanBookmarks } from './implementations/clean.bookmarks.js';
+import { getAllBookMarks } from './implementations/get.all.bookmarks.js';
+import { saveBookmarks } from './implementations/save.bookmarks.js';
+import { bookmarkManager } from './logic/bookmark.manager.js';
+export const Bookmark = () => {
+    const [index, setIndex] = useState(0);
+    const eventHandler = useContext(EventContext);
+    const textField = useContext(TextFieldContextCapture);
+    const inputController = useContext(InputContextCapture);
+    const tabs = useContext(TabsContext);
+    const bookmark = bookmarkManager(nativeOnInitJob(useRefStateFactory(), useEffectStateObserver, useEffectOnInit), getAllBookMarks, saveBookmarks, cleanBookmarks);
+    const { isBookmarkEnabled, toggleBookmarkPane } = useContext(BookmarkPaneContext);
+    const filesList = bookmark.data.value;
+    const moveUpArrow = () => {
+        setIndex((prev) => {
+            if (prev <= 0)
+                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 togglePane = () => {
+        if (!isBookmarkEnabled)
+            return toggleBookmarkPane();
+        if (!filesList || !filesList.length)
+            return;
+        return toggleBookmarkPane();
+    };
+    const selectOne = () => {
+        const item = filesList[index];
+        if (!item)
+            return;
+        toggleBookmarkPane();
+        tabs.addTab({
+            path: item.path,
+            history: {
+                forward: [],
+                previous: [],
+            },
+        });
+    };
+    const remove = () => {
+        const item = filesList[index];
+        if (!item)
+            return;
+        bookmark.removeBookmark(item);
+    };
+    const addItem = (item) => {
+        textField.addCallback({
+            placeHolder: 'Add alias',
+            callback: {
+                onChange: (data) => {
+                    const filesList = bookmark.data.value;
+                    if (filesList.some((e) => e.alias === data))
+                        textField.setError('Alias already exist');
+                    else
+                        textField.setError('');
+                },
+                onSuccess: async (data) => {
+                    if (!data)
+                        return;
+                    bookmark.saveBookmark({
+                        alias: data,
+                        path: item.path,
+                    });
+                },
+            },
+        });
+    };
+    useEffectOnInit(() => {
+        eventHandler.subscribe(ADD_BOOKMARK_ITEM, (data) => {
+            addItem(data.item);
+        });
+        eventHandler.subscribe(NODE_WRITTEN, () => {
+            bookmark.setCleanBookmarks();
+        });
+    });
+    useInput((input, key) => {
+        if (inputController.isInputEnabled || textField.isInputEnabled)
+            return;
+        if (input === 's')
+            togglePane();
+        if (!isBookmarkEnabled)
+            return;
+        if (key.downArrow)
+            moveDownArrow();
+        else if (key.upArrow)
+            moveUpArrow();
+        else if (key.return)
+            selectOne();
+        else if (input === 'd')
+            remove();
+    });
+    if (!bookmark.data.value?.length)
+        return React.createElement(React.Fragment, null);
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Box, { height: "100%", borderStyle: "round", flexDirection: "column", width: "20%" },
+            React.createElement(Box, { borderStyle: "double", width: "100%" },
+                React.createElement(Text, null, "Bookmarks:")),
+            React.createElement(BookmarkList, { index: index, items: filesList, isEnabled: isBookmarkEnabled }))));
+};

package/dist/bookmark/components/BookmarkList.js

@@ -0,0 +1,47 @@
+import { Badge } from '@inkjs/ui';
+import { Box, Text } from 'ink';
+import React, { useEffect, useMemo, useState } from 'react';
+import { useResize } from '../../file-display/hooks/useResize.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 BookmarkList = (props) => {
+    const { items, index, isEnabled } = props;
+    const [lines, setLines] = useState(0);
+    const [[top, down], setSubIndexes] = useState([
+        0,
+        lines - 1,
+    ]);
+    const [_columns, rows] = useResize();
+    useEffect(() => {
+        if (index < top) {
+            setSubIndexes([index, index + lines - 1]);
+            return;
+        }
+        if (index > down) {
+            setSubIndexes([index - lines + 1, index]);
+            return;
+        }
+    }, [lines, props.index, items, top, down]);
+    useEffect(() => {
+        const lines = rows - 6;
+        setLines(lines);
+        setSubIndexes([0, lines - 1]);
+    }, [rows]);
+    const range = useMemo(() => createRange(top, down), [top, down]);
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Box, { height: "100%", flexDirection: "column" }, items.length &&
+            range.map((e) => {
+                const item = items[e];
+                if (!item)
+                    return React.createElement(React.Fragment, null);
+                return (React.createElement(Text, { backgroundColor: index === e && isEnabled
+                        ? 'blue'
+                        : undefined }, ' ' + item.alias));
+            })),
+        React.createElement(Badge, { color: "blueBright" }, calculatePercent(items, index + 1) + '%')));
+};

package/dist/bookmark/context/BookmarkPaneContext.js

@@ -0,0 +1,9 @@
+import React, { createContext, useState } from 'react';
+export const BookmarkPaneContext = createContext(undefined);
+export const BookmarkPaneContextProvider = (props) => {
+    const [isBookmarkEnabled, setIsBookmarkEnabled] = useState(false);
+    const toggleBookmarkPane = () => {
+        setIsBookmarkEnabled((prev) => !prev);
+    };
+    return (React.createElement(BookmarkPaneContext.Provider, { value: { isBookmarkEnabled, toggleBookmarkPane } }, props.children));
+};

package/dist/bookmark/events/add.item.js

@@ -0,0 +1,8 @@
+import { randomUUID } from 'node:crypto';
+export const createAddBookmarkItem = (item) => ({
+    id: randomUUID(),
+    item,
+    name: ADD_BOOKMARK_ITEM,
+    timestamp: new Date(),
+});
+export const ADD_BOOKMARK_ITEM = 'ADD_BOOKMARK_ITEM';

package/dist/bookmark/implementations/clean.bookmarks.js

@@ -0,0 +1,6 @@
+import { existsSync } from 'node:fs';
+import { db } from '../../core/infraestructure/db/bookmark.db.js';
+export const cleanBookmarks = async () => {
+    db.data.bookmarks = db.data.bookmarks.filter((e) => existsSync(e.path));
+    await db.write();
+};

package/dist/bookmark/implementations/get.all.bookmarks.js

@@ -0,0 +1,2 @@
+import { db } from '../../core/infraestructure/db/bookmark.db.js';
+export const getAllBookMarks = async () => db.data.bookmarks;

package/dist/bookmark/implementations/save.bookmarks.js

@@ -0,0 +1,5 @@
+import { db } from '../../core/infraestructure/db/bookmark.db.js';
+export const saveBookmarks = async (bookmarks) => {
+    db.data.bookmarks = bookmarks;
+    await db.write();
+};

package/dist/bookmark/logic/bookmark.manager.js

@@ -0,0 +1,25 @@
+export const bookmarkManager = (onInitJob, getAllBookmarks, saveBookMarks, cleanBookmarks) => {
+    const bookmarksJob = onInitJob(getAllBookmarks);
+    const saveBookmark = async (item) => {
+        if (bookmarksJob.data.value?.some((e) => e.alias === item.alias))
+            throw new Error('Alias already exist');
+        await saveBookMarks([...bookmarksJob.data.value, item]);
+        bookmarksJob.reload();
+    };
+    const removeBookmark = async (item) => {
+        await saveBookMarks(bookmarksJob.data.value.filter((e) => e.alias !== item.alias));
+        bookmarksJob.reload();
+    };
+    const setCleanBookmarks = async () => {
+        await cleanBookmarks();
+        bookmarksJob.reload();
+    };
+    return {
+        data: bookmarksJob.data,
+        isLoading: bookmarksJob.isLoading,
+        error: bookmarksJob.error,
+        saveBookmark,
+        removeBookmark,
+        setCleanBookmarks,
+    };
+};

package/dist/bookmark/services/clean.bookmarks.js

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

package/dist/bookmark/services/get.all.bookmarks.js

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

package/dist/bookmark/services/write.bookmarks.js

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

package/dist/bookmark/types/bookmark.js

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

package/dist/cli.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { withFullScreen } from 'fullscreen-ink';
+import React from 'react';
+import meow from 'meow';
+import App from './app.js';
+import { join } from 'node:path';
+const cli = meow(`
+	Usage
+	  $ files
+
+	Options
+		--path  The default path, if not provided uses working directory
+		-p  Alias for --path
+
+	Examples
+	  $ files -p ./dir
+`, {
+    importMeta: import.meta,
+    flags: {
+        path: {
+            type: 'string',
+        },
+        p: {
+            type: 'string',
+        },
+    },
+});
+let defaultPath = process.cwd().replaceAll('\\', '/');
+if (cli.flags.path || cli.flags.p)
+    defaultPath = join(process.cwd(), cli.flags.p ?? cli.flags.path ?? '').replaceAll('\\', '/');
+withFullScreen(React.createElement(App, { defaultPath: defaultPath })).start();

package/dist/clipboard/ClipboardProvider.js

@@ -0,0 +1,8 @@
+import React, { createContext } from 'react';
+import { useStateFactory } from '../core/infraestructure/state/useStateProvider.js';
+import { clipboardLogic } from './logic/clipboard-logic.js';
+export const ClipboardContext = createContext(undefined);
+export const ClipboardProvider = (props) => {
+    const data = clipboardLogic(useStateFactory);
+    return (React.createElement(ClipboardContext.Provider, { value: data }, props.children));
+};

package/dist/clipboard/logic/clipboard-logic.js

@@ -0,0 +1,10 @@
+export const clipboardLogic = (stateFactory) => {
+    const clipboardItemState = stateFactory(undefined);
+    const removeItem = () => clipboardItemState.setState(undefined);
+    const setItem = (item) => clipboardItemState.setState(item);
+    return {
+        item: clipboardItemState.state,
+        removeItem,
+        setItem,
+    };
+};

package/dist/core/application/event-handler/event-handler.js

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

package/dist/core/application/event-handler/listener/event-listener.js

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

package/dist/core/application/event-handler/types/event.js

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

package/dist/core/application/event-handler/types/subscription.js

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

package/dist/core/application/id-generator/id.generator.js

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

package/dist/core/application/init-layout/init-layout.js

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

package/dist/core/application/input-manager/input-manager.js

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

package/dist/core/application/input-manager/types/input-manager-result.js

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

package/dist/core/application/on-init/on-init.js

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

package/dist/core/application/on-init-job/lazy/on-init-job-lazy.js

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

package/dist/core/application/on-init-job/on-init-job.js

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

package/dist/core/application/pagination-manager/pagination-manager.js

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

package/dist/core/application/pagination-manager/types/pagination-result.js

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

package/dist/core/application/service/application-service.js

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

package/dist/core/application/state/state-factory.js

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

package/dist/core/application/state/state-provider.js

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

package/dist/core/application/state-observers/state-observer.js

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

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

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

package/dist/core/application/timer/timer.js

@@ -0,0 +1,19 @@
+export const timerManager = (stateFactory, valueProvider, stateObserver, time, sleep) => {
+    const callBackState = stateFactory(undefined);
+    const currentCallback = valueProvider(undefined);
+    const worker = async () => {
+        await sleep(time);
+        callBackState.state.value?.();
+        callBackState.setState(undefined);
+    };
+    const addCallback = (callback) => {
+        currentCallback.value = callBackState.state.value;
+        callBackState.setState(callback);
+    };
+    stateObserver(() => {
+        if (callBackState.state.value)
+            worker();
+        return () => worker();
+    }, callBackState.state);
+    return addCallback;
+};

package/dist/core/application/value-provider/value-provider.js

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

package/dist/core/infraestructure/db/bookmark.db.js

@@ -0,0 +1,4 @@
+import { JSONFilePreset } from 'lowdb/node';
+export const db = await JSONFilePreset('db.json', {
+    bookmarks: [],
+});

package/dist/core/infraestructure/event-handler/context/EventProvider.js

@@ -0,0 +1,9 @@
+import React, { createContext, useContext } from 'react';
+import { useRefValueProvider } from '../../value-provider/useRefValueProvider.js';
+import { useEventHadler } from '../useEventHadler.js';
+export const EventContext = createContext(undefined);
+export const getEventContext = () => useContext(EventContext);
+export const EventProvider = (props) => {
+    const eventHandler = useEventHadler(useRefValueProvider());
+    return (React.createElement(EventContext.Provider, { value: eventHandler }, props.children));
+};

package/dist/core/infraestructure/event-handler/listener/event-listener-factory.js

@@ -0,0 +1,8 @@
+export const eventListenerFactory = (onInit, eventHandler) => (event, callback) => {
+    onInit(() => {
+        const subscription = eventHandler.subscribe(event, callback);
+        return () => {
+            subscription();
+        };
+    });
+};

package/dist/core/infraestructure/event-handler/useEventHadler.js

@@ -0,0 +1,27 @@
+export const useEventHadler = (valueFactory) => {
+    const callbacksState = valueFactory({});
+    const subscribe = (event, callback) => {
+        const callbacks = [
+            ...(callbacksState.value[event] || []),
+            callback,
+        ];
+        callbacksState.value = {
+            ...callbacksState.value,
+            [event]: callbacks,
+        };
+        return () => {
+            const callbacks = callbacksState.value[event]?.filter((e) => e !== callback) || [];
+            callbacksState.value = {
+                ...callbacksState.value,
+                [event]: callbacks,
+            };
+        };
+    };
+    const publish = (event) => {
+        callbacksState.value[event.name]?.forEach((callback) => callback(event));
+    };
+    return {
+        subscribe,
+        publish,
+    };
+};

package/dist/core/infraestructure/initLayout/useLayoutEffectOnInit.js

@@ -0,0 +1,4 @@
+import { useLayoutEffect } from 'react';
+export const useLayoutEffectInitLayout = (callback) => {
+    useLayoutEffect(callback, []);
+};

package/dist/core/infraestructure/input-manager/useInputManager.js

@@ -0,0 +1,14 @@
+export const useInputManager = (stateFactory) => (initialValue, validator = (_) => '', dataTransform = (d) => d) => {
+    const inputState = stateFactory(initialValue);
+    const errorState = stateFactory('');
+    const onChange = (value) => {
+        const transformed = dataTransform(value);
+        inputState.setState(transformed);
+        errorState.setState(validator(transformed));
+    };
+    return {
+        value: inputState.state,
+        error: errorState.state,
+        onChange,
+    };
+};

package/dist/core/infraestructure/on-init/useEffectOnInit.js

@@ -0,0 +1,9 @@
+import { useEffect } from 'react';
+export const useEffectOnInit = (callback) => {
+    useEffect(() => {
+        const res = callback();
+        return () => {
+            res?.();
+        };
+    }, []);
+};

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

@@ -0,0 +1,37 @@
+export const nativeOnInitJob = (stateFactory, stateObserver, onInit) => (callback, ...args) => {
+    const dataState = stateFactory(null);
+    const loadingState = stateFactory(false);
+    const errorState = stateFactory(null);
+    const reloadingState = stateFactory(false);
+    const job = async () => {
+        dataState.setState(null);
+        errorState.setState(null);
+        try {
+            const res = await callback();
+            dataState.setState(res);
+        }
+        catch (e) {
+            errorState.setState(e);
+        }
+        loadingState.setState(false);
+        reloadingState.setState(false);
+    };
+    onInit(() => {
+        loadingState.setState(true);
+        job();
+    });
+    const reload = () => {
+        if (reloadingState.state.value || loadingState.state.value)
+            throw new Error('Is in job');
+        reloadingState.setState(true);
+        job();
+    };
+    stateObserver(reload, ...args);
+    return {
+        reload,
+        data: dataState.state,
+        error: errorState.state,
+        isLoading: loadingState.state,
+        isReloading: reloadingState.state,
+    };
+};