filefive 1.0.0

package/dist/commands/remove.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const types_1 = require("../types");
+const promises_1 = require("node:fs/promises");
+const Local_1 = require("../Local");
+const URI_1 = require("../utils/URI");
+const uniqid_1 = __importDefault(require("../utils/uniqid"));
+const Queue_1 = require("../queues/Queue");
+const Remove_1 = __importDefault(require("../queues/Remove"));
+const trash = import("trash");
+const App_1 = __importDefault(require("../App"));
+const ramda_1 = require("ramda");
+async function default_1(files, force, connPath, immediately = false) {
+    if (!files.length) {
+        return;
+    }
+    if (!force) {
+        App_1.default.onError({ type: types_1.FailureType.ConfirmDeletion, files });
+        return;
+    }
+    if ((0, URI_1.isLocal)(files[0])) {
+        const paths = files.map(p => (0, URI_1.parseURI)(p)['path']);
+        if (immediately) {
+            paths.forEach(path => (0, promises_1.rm)(path, { recursive: true, force: true }));
+        }
+        else {
+            (await trash).default(paths);
+        }
+        paths.forEach(path => {
+            if (path.startsWith(connPath) && !(0, Local_1.stat)(path)?.dir) {
+                // TODO delete from credentials
+            }
+        });
+    }
+    else {
+        const connId = (0, URI_1.parseURI)(files[0])['id'];
+        const id = (0, uniqid_1.default)();
+        const queue = new Remove_1.default(connId, files.map((0, ramda_1.pipe)(URI_1.parseURI, (0, ramda_1.prop)('path'))), state => App_1.default.onQueueUpdate(id, { type: types_1.QueueEventType.Update, state }), error => {
+            App_1.default.onError({
+                type: types_1.FailureType.RemoteError,
+                id: this.connId,
+                message: error.message ?? String(error)
+            });
+        }, () => {
+            Queue_1.queues.delete(id);
+            App_1.default.onQueueUpdate(id, { type: types_1.QueueEventType.Complete });
+        }, App_1.default.remoteWatcher);
+        Queue_1.queues.set(id, queue);
+        App_1.default.onQueueUpdate(id, { type: types_1.QueueEventType.Create, queueType: types_1.QueueType.Remove, connection: connId });
+        queue.create();
+    }
+}

package/dist/commands/rename.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const node_path_1 = require("node:path");
+const URI_1 = require("../utils/URI");
+const Connection_1 = __importDefault(require("../Connection"));
+const App_1 = __importDefault(require("../App"));
+async function default_1(uri, name) {
+    const { id, path } = (0, URI_1.parseURI)(uri);
+    const to = (0, node_path_1.join)((0, node_path_1.dirname)(path), name);
+    if (path == to) {
+        return;
+    }
+    await Connection_1.default.get(id).rename(path, to);
+    if (!(0, URI_1.isLocal)(uri)) {
+        App_1.default.remoteWatcher.refresh((0, URI_1.createURI)(id, (0, node_path_1.dirname)(path)));
+    }
+}

package/dist/commands/resolve.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const Queue_1 = require("../queues/Queue");
+const Session_1 = __importDefault(require("../Session"));
+function default_1(id, action, forAll, sid) {
+    if (sid) {
+        Session_1.default.set(sid, { action });
+    }
+    Queue_1.queues.get(id)?.resolve(action, forAll);
+}

package/dist/commands/saveConnection.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSettings = getSettings;
+exports.default = default_1;
+const Local_1 = require("../Local");
+const URI_1 = require("../utils/URI");
+const Local_2 = require("../Local");
+const ramda_1 = require("ramda");
+const promises_1 = require("node:fs/promises");
+const Password_1 = __importDefault(require("../Password"));
+function getSettings(settings) {
+    return {
+        columns: settings.columns.filter((0, ramda_1.whereEq)({ visible: true })).map(({ name, width }) => ({ name, width })),
+        sort: settings.sort,
+        history: settings.history,
+        filter: settings.filter
+    };
+}
+async function default_1(path, settings) {
+    const content = (0, Local_2.stat)(path) ? await (0, Local_1.read)(path) : null;
+    if ((0, Local_2.stat)(path) && !content) {
+        throw new Error(`Cant read connection file: ${path} ${typeof content}`);
+    }
+    let config = content ? JSON.parse(content) : {};
+    if ('scheme' in settings) {
+        config = { ...config, ...(0, ramda_1.omit)(['password'], settings) };
+        if (settings.password.length) {
+            Password_1.default.save((0, URI_1.connectionID)(settings.scheme, settings.user, settings.host, settings.port), settings.password);
+        }
+    }
+    else {
+        if (settings.local) {
+            config.local = getSettings(settings.local);
+        }
+        if (settings.remote) {
+            config.remote = getSettings(settings.remote);
+        }
+        if (settings.path) {
+            config.path = settings.path;
+        }
+        config.sync = settings.sync;
+    }
+    if (!config) {
+        throw new Error(`Save invalid config into ${path}`);
+    }
+    await (0, promises_1.writeFile)(path, JSON.stringify(config));
+}

package/dist/commands/saveSettings.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const promises_1 = require("node:fs/promises");
+const saveConnection_1 = require("./saveConnection");
+const ramda_1 = require("ramda");
+const _1 = require(".");
+async function default_1(path, changes) {
+    const settings = (0, ramda_1.mergeDeepRight)(await _1.commands.getSettings(path), changes);
+    const config = {
+        mode: settings.mode,
+        theme: settings.theme,
+        timeFmt: settings.timeFmt,
+        sizeFmt: settings.sizeFmt,
+        local: (0, saveConnection_1.getSettings)(settings.local),
+        remote: (0, saveConnection_1.getSettings)(settings.remote),
+        path: settings.path,
+        sync: settings.sync
+    };
+    await (0, promises_1.writeFile)(path, JSON.stringify(config));
+}

package/dist/commands/settings.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const Local_1 = require("../Local");
+const Local_2 = require("../fs/Local");
+const connect_1 = require("./connect");
+const keybindings_json_1 = __importDefault(require("../keybindings.json"));
+async function default_1(path) {
+    let config = null;
+    try {
+        config = JSON.parse(await (0, Local_1.read)(path));
+    }
+    catch (e) { }
+    return {
+        home: (0, node_os_1.homedir)(),
+        settings: (0, node_path_1.join)((0, node_os_1.homedir)(), '.f5', 'settings.json'),
+        connections: (0, node_path_1.join)((0, node_os_1.homedir)(), '.f5', 'connections'),
+        keybindings: keybindings_json_1.default,
+        mode: config?.mode ?? 'system',
+        theme: config?.theme ?? 'black',
+        timeFmt: config?.timeFmt ?? 'yyyy-MM-dd HH:mm',
+        sizeFmt: config?.sizeFmt ?? '0.0 b',
+        local: (0, connect_1.explorerSettings)(Local_2.ATTRIBUTES, config?.local),
+        remote: (0, connect_1.explorerSettings)(Local_2.ATTRIBUTES, config?.remote),
+        path: config?.path ?? { local: (0, node_os_1.homedir)(), remote: (0, node_os_1.homedir)() },
+        sync: config?.sync ?? null
+    };
+}

package/dist/commands/unwatch.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const URI_1 = require("../utils/URI");
+async function default_1(uri, local, remote, file) {
+    if ((0, URI_1.isLocal)(uri)) {
+        const { path } = (0, URI_1.parseURI)(uri);
+        local.unwatch(path);
+        file.unwatch(path);
+    }
+    else {
+        remote.unwatch(uri);
+    }
+}

package/dist/commands/watch.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const URI_1 = require("../utils/URI");
+const Local_1 = require("../Local");
+async function default_1(uri, local, remote, file) {
+    if ((0, URI_1.isLocal)(uri)) {
+        const { path } = (0, URI_1.parseURI)(uri);
+        const f = (0, Local_1.stat)(path);
+        if (f) {
+            if (f.dir) {
+                local.watch(path);
+            }
+            else {
+                file.watch(path);
+            }
+        }
+        else {
+            local.watch(path);
+        }
+    }
+    else {
+        remote.watch(uri);
+    }
+}

package/dist/commands/write.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const Connection_1 = __importDefault(require("../Connection"));
+const URI_1 = require("../utils/URI");
+const node_path_1 = require("node:path");
+const App_1 = __importDefault(require("../App"));
+async function default_1(file, content) {
+    const { id, path } = (0, URI_1.parseURI)(file);
+    await Connection_1.default.get(id).write(path, content);
+    if (!(0, URI_1.isLocal)(file)) {
+        App_1.default.remoteWatcher.refresh((0, URI_1.createURI)(id, (0, node_path_1.dirname)(path)));
+    }
+}

package/dist/fs/Ftp.js

@@ -0,0 +1,188 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ATTRIBUTES = void 0;
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const promises_1 = require("node:fs/promises");
+const fs = __importStar(require("fs"));
+const ftp_1 = __importDefault(require("ftp"));
+const FileSystem_1 = require("../FileSystem");
+// https://github.com/mscdex/node-ftp
+exports.ATTRIBUTES = [
+    {
+        name: "name",
+        type: FileSystem_1.FileAttributeType.String,
+        title: "Name"
+    },
+    {
+        name: "size",
+        type: FileSystem_1.FileAttributeType.Number,
+        title: "Size"
+    },
+    {
+        name: "modified",
+        type: FileSystem_1.FileAttributeType.Date,
+        title: "Last Modified"
+    },
+    {
+        name: "rights",
+        type: FileSystem_1.FileAttributeType.Rights,
+        title: "Rights"
+    }
+];
+function parseRights(part) {
+    return (part.includes('r') ? 'r' : '-') + (part.includes('w') ? 'w' : '-') + (part.includes('x') ? 'x' : '-');
+}
+class Ftp extends FileSystem_1.FileSystem {
+    constructor(host, user, password, port = 21, onError, onClose = () => { }) {
+        super();
+        this.host = host;
+        this.user = user;
+        this.password = password;
+        this.port = port;
+        this.onError = onError;
+        this.onClose = onClose;
+        this.connection = new ftp_1.default();
+        this.connection.on('close', () => {
+            this.connected = undefined;
+            this.onClose();
+        });
+    }
+    async open() {
+        if (this.connected === undefined) {
+            this.connected = new Promise((resolve, reject) => {
+                this.connection
+                    .on('ready', () => {
+                    this.connection.on('error', this.onError);
+                    resolve(this.uri = `ftp://${this.user}@${this.host}:${this.port}`);
+                })
+                    .on('error', reject);
+            });
+            this.connection.connect({ host: this.host, user: this.user, password: this.password, port: this.port });
+        }
+        return this.connected;
+    }
+    close() {
+        this.connected != undefined && this.connection.end();
+    }
+    opened() {
+        return this.connected != undefined;
+    }
+    async pwd() {
+        await this.open();
+        return new Promise((resolve, reject) => this.connection.pwd((e, pwd) => e ? reject(e) : resolve(pwd)));
+    }
+    async ls(dir) {
+        await this.open();
+        return new Promise((resolve, reject) => {
+            this.connection.list(dir, (err, list) => {
+                err ?
+                    reject(err) :
+                    resolve(list
+                        .filter(f => f.name != '.' && f.name != '..')
+                        .map(f => {
+                        let target = f.target;
+                        if (target && !(0, node_path_1.isAbsolute)(target)) {
+                            target = (0, node_path_1.normalize)((0, node_path_1.join)(dir, target));
+                        }
+                        return {
+                            path: (0, node_path_1.join)(dir, f.name),
+                            name: f.name,
+                            dir: f.type == 'd',
+                            size: f.size,
+                            modified: f.date,
+                            owner: f.owner,
+                            group: f.group,
+                            rights: f.rights ? parseRights(f.rights.user) + parseRights(f.rights.group) + parseRights(f.rights.other) : '',
+                            target
+                        };
+                    }));
+            });
+        });
+    }
+    async get(fromRemote, toLocal) {
+        await this.open();
+        return new Promise((resolve, reject) => {
+            this.connection.get(fromRemote, (err, source) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    const dest = fs.createWriteStream(toLocal);
+                    dest.on('finish', () => resolve());
+                    source.pipe(dest);
+                }
+            });
+        });
+    }
+    async put(fromLocal, toRemote) {
+        await this.open();
+        return new Promise((resolve, reject) => {
+            this.connection.put(fromLocal, toRemote, e => e ? reject(e) : resolve());
+        });
+    }
+    async rm(path, recursive) {
+        await this.open();
+        return new Promise((resolve, reject) => recursive ?
+            this.connection.rmdir(path, true, e => e ? reject(e) : resolve()) :
+            this.connection.delete(path, e => e ? reject(e) : resolve()));
+    }
+    async mkdir(path) {
+        await this.open();
+        return new Promise((resolve, reject) => this.connection.mkdir(path, true, e => e ? reject(e) : resolve()));
+    }
+    async rename(from, to) {
+        await this.open();
+        return new Promise((resolve, reject) => this.connection.rename(from, to, e => e ? reject(e) : resolve()));
+    }
+    async mv(from, to) {
+        await this.open();
+        return new Promise((resolve, reject) => this.connection.rename(from, to, e => e ? reject(e) : resolve()));
+    }
+    async cp(from, to, recursive) {
+        return Promise.reject(new Error("FTP doesn't support remote duplication"));
+    }
+    async write(path, s) {
+        const tmp = (0, node_path_1.join)((0, node_os_1.tmpdir)(), (0, node_path_1.basename)(path));
+        await (0, promises_1.writeFile)(tmp, s);
+        await this.put(tmp, path);
+        (0, promises_1.rm)(tmp);
+    }
+}
+exports.default = Ftp;

package/dist/fs/Local.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ATTRIBUTES = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const FileSystem_1 = require("../FileSystem");
+const Local_1 = require("../Local");
+const types_1 = require("../types");
+exports.ATTRIBUTES = [
+    {
+        name: "name",
+        type: FileSystem_1.FileAttributeType.String,
+        title: "Name"
+    },
+    {
+        name: "size",
+        type: FileSystem_1.FileAttributeType.Number,
+        title: "Size"
+    },
+    {
+        name: "modified",
+        type: FileSystem_1.FileAttributeType.Date,
+        title: "Last Modified"
+    }
+];
+class Local extends FileSystem_1.FileSystem {
+    open() {
+        return Promise.resolve(types_1.LocalFileSystemID);
+    }
+    opened() { return true; }
+    close() { }
+    pwd() {
+        return Promise.resolve((0, Local_1.pwd)());
+    }
+    ls(dir) {
+        return Promise.resolve((0, Local_1.list)(dir));
+    }
+    async get(fromRemote, toLocal) {
+        await (0, Local_1.copy)(fromRemote, toLocal, true);
+    }
+    async put(fromLocal, toRemote) {
+        await (0, Local_1.copy)(fromLocal, toRemote);
+    }
+    async rm(path, recursive) {
+        return (0, Local_1.del)(path);
+    }
+    async mkdir(path) {
+        await (0, promises_1.mkdir)(path, { recursive: true });
+    }
+    async rename(from, to) {
+        await (0, promises_1.rename)(from, to);
+    }
+    async mv(from, to) {
+        try {
+            await (0, Local_1.del)(to);
+        }
+        catch (e) { }
+        await (0, promises_1.mkdir)((0, node_path_1.dirname)(to), { recursive: true });
+        await (0, promises_1.rename)(from, to);
+    }
+    async cp(from, to, recursive) {
+        await (0, promises_1.cp)(from, to, { recursive, force: true });
+    }
+    async write(path, data) {
+        await (0, promises_1.writeFile)(path, data);
+    }
+}
+exports.default = Local;