filefive 1.0.0

package/dist/public/index.js.LICENSE.txt

@@ -0,0 +1,43 @@
+/*!
+	Copyright (c) 2018 Jed Watson.
+	Licensed under the MIT License (MIT), see
+	http://jedwatson.github.io/classnames
+*/
+
+/*! @preserve
+ * numeral.js
+ * version : 2.0.6
+ * author : Adam Draper
+ * license : MIT
+ * http://adamwdraper.github.com/Numeral-js/
+ */
+
+/**
+ * @license React
+ * react-dom.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * @license React
+ * react.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * @license React
+ * scheduler.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */

package/dist/queues/Copy.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = require("node:path");
+const Queue_1 = __importDefault(require("./Queue"));
+const types_1 = require("../types");
+const URI_1 = require("../utils/URI");
+class CopyQueue extends Queue_1.default {
+    constructor(connId, src, dest, filter, onState, onConflict, onError, onComplete, watcher, move) {
+        super(connId, connId, src, dest, filter, onState, onConflict, onComplete);
+        this.onError = onError;
+        this.watcher = watcher;
+        this.move = move;
+        this.touched = new Map();
+    }
+    async enqueue(paths, dest) {
+        if (this.move) { // No filter
+            const stat = this.stat(this.from);
+            await Promise.all(paths
+                .filter(path => path != dest && (0, node_path_1.dirname)(path) != dest)
+                .map(async (path) => {
+                const from = await stat(path);
+                if (from) {
+                    this.queue.push({
+                        from,
+                        dirs: [],
+                        to: this.dest
+                    });
+                    this.totalCnt++;
+                    this.totalSize++;
+                }
+            }));
+        }
+        else {
+            await super.enqueue(paths, dest);
+        }
+    }
+    async transmit(fs, from, dirs, to) {
+        if (this.stopped) {
+            return;
+        }
+        try {
+            let p;
+            if (this.move) {
+                p = fs.mv(from.path, (0, node_path_1.join)(to, ...dirs, from.name));
+                const parent = (0, node_path_1.dirname)(from.path);
+                this.touched.set(parent, [...(this.touched.get(parent) ?? []), p]);
+            }
+            else {
+                p = fs.cp(from.path, (0, node_path_1.join)(to, ...dirs, from.name), from.dir);
+            }
+            await p;
+            this.touched.set(to, [...(this.touched.get(to) ?? []), p]);
+        }
+        catch (error) {
+            this.onError(error);
+        }
+        this.sendState(from.size);
+    }
+    async finalize() {
+        if (this.to != types_1.LocalFileSystemID) {
+            await Promise.all(Array.from(this.touched.values()).flat());
+            Array.from(this.touched.keys()).forEach(path => this.watcher.refresh((0, URI_1.createURI)(this.to, path)));
+        }
+    }
+}
+exports.default = CopyQueue;

package/dist/queues/Download.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = require("node:path");
+const Queue_1 = __importDefault(require("./Queue"));
+const types_1 = require("../types");
+const Local_1 = require("../Local");
+class DownloadQueue extends Queue_1.default {
+    constructor(connId, src, dest, filter, onState, onConflict, onError, onComplete) {
+        super(connId, types_1.LocalFileSystemID, src, dest, filter, onState, onConflict, onComplete);
+        this.onError = onError;
+    }
+    async transmit(fs, from, dirs, to) {
+        if (this.stopped) {
+            return;
+        }
+        const dest = (0, node_path_1.join)(to, ...dirs, from.name);
+        await (0, Local_1.touch)(dest);
+        try {
+            await fs.get(from.path, dest);
+        }
+        catch (error) {
+            this.onError(error);
+        }
+        this.sendState(from.size);
+    }
+}
+exports.default = DownloadQueue;

package/dist/queues/Duplicate.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Copy_1 = __importDefault(require("./Copy"));
+const types_1 = require("../types");
+class DuplicateQueue extends Copy_1.default {
+    constructor(connId, src, dest, filter, onState, onConflict, onError, onComplete, watcher) {
+        super(connId, src, dest, filter, onState, onConflict, onError, onComplete, watcher, false);
+        this.newNames = new Map();
+        this.resolve({ type: types_1.QueueActionType.Rename }, true);
+    }
+    async enqueue(paths, dest) {
+        await super.enqueue(paths, dest);
+        for (const item of this.queue) {
+            if (item.dirs.length) {
+                const name = item.dirs[0];
+                if (!this.newNames.has(name)) {
+                    this.newNames.set(name, await this.rename(name, item.to));
+                }
+                item.dirs[0] = this.newNames.get(name);
+            }
+        }
+    }
+}
+exports.default = DuplicateQueue;

package/dist/queues/Queue.js

@@ -0,0 +1,214 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queues = exports.lsRemote = void 0;
+const node_path_1 = require("node:path");
+const types_1 = require("../types");
+const rxjs_1 = require("rxjs");
+const ramda_1 = require("ramda");
+const Connection_1 = __importDefault(require("../Connection"));
+const Local_1 = require("../Local");
+const filter_1 = require("../utils/filter");
+const lsRemote = (connId) => {
+    const cache = new Map();
+    return async (path) => {
+        if (cache.has(path)) {
+            return cache.get(path);
+        }
+        const list = new Promise(async (resove) => {
+            const [conn, close] = await Connection_1.default.transmit(connId);
+            conn.ls(path)
+                .then(resove)
+                .catch(() => resove(null))
+                .finally(() => close());
+        });
+        cache.set(path, list);
+        return list;
+    };
+};
+exports.lsRemote = lsRemote;
+class TransmitQueue {
+    constructor(from, to, src, dest, filter, onState, onConflict, onComplete) {
+        this.from = from;
+        this.to = to;
+        this.src = src;
+        this.dest = dest;
+        this.filter = filter;
+        this.onState = onState;
+        this.onConflict = onConflict;
+        this.onComplete = onComplete;
+        this.queue$ = new rxjs_1.Subject();
+        this.queue = [];
+        this.pending = [];
+        this.stopped = false;
+        this.totalCnt = 0;
+        this.doneCnt = 0;
+        this.totalSize = 0;
+        this.doneSize = 0;
+        this.transmits = 0;
+        this.closed = false;
+    }
+    async create() {
+        await this.enqueue(this.src, this.dest);
+        if (this.stopped) {
+            return;
+        }
+        const stat = this.stat(this.to);
+        this.processing = this.queue$.subscribe(async ({ from, dirs, to, action }) => {
+            let a = action ?? this.action;
+            const existing = await stat((0, node_path_1.join)(to, ...dirs, from.name));
+            if (existing) {
+                if (a) {
+                    if (a.type == types_1.QueueActionType.Skip) {
+                        this.sendState(from.size);
+                        return this.next();
+                    }
+                }
+                else {
+                    this.putOnHold(from, dirs, to, existing);
+                    return this.next();
+                }
+            }
+            const [fs, close] = await Connection_1.default.transmit(this.from != types_1.LocalFileSystemID ? this.from : this.to);
+            this.transmits++;
+            (new Promise((resolve) => resolve(existing ?
+                this.applyAction(a, from, dirs, to, existing, this.transmit.bind(this, fs)) :
+                this.transmit(fs, from, dirs, to)))).then(() => {
+                close();
+                if (--this.transmits == 0 && this.closed) {
+                    this.close();
+                }
+            });
+            this.next();
+        });
+        this.next();
+    }
+    async enqueue(paths, dest) {
+        const ls = this.ls(this.from);
+        let matchFilter = (file) => true;
+        if (this.filter) {
+            const re = (0, filter_1.filterRegExp)(this.filter);
+            matchFilter = (file) => {
+                const found = re.exec(file.name);
+                return this.filter?.invert ?? false ? found === null : found !== null;
+            };
+        }
+        paths = paths.map(node_path_1.normalize).filter(path => !paths.find(ancestor => path.startsWith(ancestor + node_path_1.sep)));
+        const add = async (path, to, dirs = []) => {
+            if (this.stopped) {
+                return;
+            }
+            const parent = (0, node_path_1.dirname)(path);
+            const from = (await ls(parent))?.find((0, ramda_1.whereEq)({ path }));
+            if (from) {
+                if (from.dir) {
+                    return Promise.all((await ls(from.path))?.map(child => add(child.path, to, [...dirs, (0, node_path_1.basename)(path)])));
+                }
+                else {
+                    if (matchFilter(from)) {
+                        this.queue.push({ from, to, dirs });
+                        this.totalCnt++;
+                        this.totalSize += from.size;
+                    }
+                }
+            }
+        };
+        await Promise.all(paths.map(path => add(path, dest)));
+    }
+    stop() {
+        if (!this.stopped) {
+            this.stopped = true;
+            this.pending = [];
+            this.close();
+        }
+    }
+    resolve(action, forAll = false) {
+        forAll && (this.action = action);
+        const drained = !this.queue.length;
+        this.queue.push(...this.pending
+            .splice(0, forAll ? this.pending.length : 1)
+            .map(f => ({ from: f.src, dirs: f.dirs, to: f.to, action })));
+        drained && this.queue$.next(this.queue.shift());
+        if (this.pending.length) {
+            const { src, dest } = this.pending[0];
+            this.onConflict(src, dest);
+        }
+    }
+    next() {
+        if (this.queue.length) {
+            this.queue$.next(this.queue.shift());
+        }
+        else if (!this.pending.length) {
+            this.close();
+        }
+    }
+    async close() {
+        if (this.processing?.closed === false) {
+            this.processing?.unsubscribe();
+        }
+        this.closed = true;
+        if (this.transmits == 0) {
+            this.finalize();
+            this.onComplete(this.stopped);
+        }
+    }
+    sendState(size) {
+        this.doneCnt++;
+        this.doneSize += size;
+        this.onState({
+            totalCnt: this.totalCnt,
+            doneCnt: this.doneCnt,
+            totalSize: this.totalSize,
+            doneSize: this.doneSize,
+            pending: this.pending.length
+        });
+    }
+    async applyAction(action, from, dirs, to, existing, transmit) {
+        switch (action.type) {
+            case types_1.QueueActionType.Replace: {
+                await transmit(from, dirs, to);
+                break;
+            }
+            case types_1.QueueActionType.Rename: {
+                from.name = await this.rename(from.name, (0, node_path_1.join)(to, ...dirs));
+                await transmit(from, dirs, to);
+                break;
+            }
+        }
+    }
+    putOnHold(src, dirs, to, dest) {
+        this.pending.push({ src, dirs, to, dest });
+        if (this.pending.length == 1) {
+            this.onConflict(src, dest);
+        }
+    }
+    ls(connId) {
+        return connId == types_1.LocalFileSystemID ?
+            (dir) => Connection_1.default.get(connId).ls(dir) :
+            (0, exports.lsRemote)(connId);
+    }
+    stat(connId) {
+        if (connId == types_1.LocalFileSystemID) {
+            return (path) => Promise.resolve((0, Local_1.stat)(path));
+        }
+        const ls = this.ls(connId);
+        return async (path) => (await ls((0, node_path_1.dirname)(path)))?.find((0, ramda_1.whereEq)({ path }));
+    }
+    async rename(name, dir) {
+        let { name: oldName, ext } = (0, node_path_1.parse)(name);
+        const parts = oldName.match(/^(.+) copy ?(\d*)$/);
+        oldName = (parts && parts.length > 2) ? parts[1] : oldName;
+        let counter = (parts && parts.length > 2) ? (parts[2] ? parseInt(parts[2]) + 1 : 1) : 1;
+        let newName = `${oldName} copy${counter > 1 ? ' ' + counter : ''}`;
+        const files = await this.ls(this.to)(dir);
+        while (files?.find((0, ramda_1.whereEq)({ name: newName + ext }))) {
+            newName = `${oldName} copy ${++counter}`;
+        }
+        return newName + ext;
+    }
+    async finalize() { }
+}
+exports.default = TransmitQueue;
+exports.queues = new Map();

package/dist/queues/Remove.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = require("node:path");
+const Connection_1 = __importDefault(require("../Connection"));
+const URI_1 = require("../utils/URI");
+const Queue_1 = require("./Queue");
+class RemoveQueue {
+    constructor(connId, paths, onState, onError, onComplete, watcher) {
+        this.connId = connId;
+        this.paths = paths;
+        this.onState = onState;
+        this.onError = onError;
+        this.onComplete = onComplete;
+        this.watcher = watcher;
+        this.touched = new Set();
+        this.stopped = false;
+    }
+    async create() {
+        const paths = this.paths.map(node_path_1.normalize).filter(path => !this.paths.find(ancestor => path.startsWith(ancestor + node_path_1.sep)));
+        let totalCnt = 0;
+        let doneCnt = 0;
+        const ls = (0, Queue_1.lsRemote)(this.connId);
+        const add = async (path, tree) => {
+            const parent = (0, node_path_1.dirname)(path);
+            const file = (await ls(parent))?.find(f => f.name == (0, node_path_1.basename)(path));
+            if (!file) {
+                return tree;
+            }
+            this.touched.add(parent);
+            let children = [];
+            if (file.dir) {
+                children = (await Promise.all((await ls(file.path) ?? []).map(({ path }) => add(path, [])))).flat(1);
+            }
+            totalCnt++;
+            return [...tree, { path, dir: file.dir, children }];
+        };
+        const files = [];
+        for (const path of paths) {
+            files.push(...await add(path, []));
+        }
+        if (this.stopped) {
+            return;
+        }
+        const rm = async (item) => {
+            for (const child of item.children) {
+                await rm(child);
+            }
+            const [conn, close] = await Connection_1.default.transmit(this.connId);
+            if (this.stopped) {
+                close();
+                return;
+            }
+            try {
+                await conn.rm(item.path, item.dir);
+                this.onState({
+                    totalCnt,
+                    doneCnt: ++doneCnt,
+                    totalSize: 0,
+                    doneSize: 0,
+                    pending: 0
+                });
+            }
+            catch (error) {
+                this.onError(error);
+            }
+            finally {
+                close();
+            }
+        };
+        await Promise.allSettled(files.map(rm));
+        this.touched.forEach(path => this.watcher.refresh((0, URI_1.createURI)(this.connId, path)));
+        this.onComplete(this.stopped);
+    }
+    stop() {
+        this.stopped = true;
+    }
+    resolve(action, forAll) { }
+}
+exports.default = RemoveQueue;

package/dist/queues/Upload.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = require("node:path");
+const Queue_1 = __importDefault(require("./Queue"));
+const types_1 = require("../types");
+const Local_1 = require("../Local");
+const URI_1 = require("../utils/URI");
+class UploadQueue extends Queue_1.default {
+    constructor(connId, src, dest, filter, onState, onConflict, onError, onComplete, watcher) {
+        super(types_1.LocalFileSystemID, connId, src, dest, filter, onState, onConflict, onComplete);
+        this.onError = onError;
+        this.watcher = watcher;
+        this.touched = new Map();
+    }
+    async transmit(fs, from, dirs, to) {
+        if (this.stopped) {
+            return;
+        }
+        if (!((0, Local_1.stat)(from.path))) {
+            return;
+        }
+        try {
+            let targetDir = to;
+            for (const dir of dirs) {
+                targetDir = (0, node_path_1.join)(targetDir, dir);
+                if (this.touched.has(targetDir)) {
+                    await this.touched.get(targetDir);
+                }
+                else {
+                    this.touched.set(targetDir, new Promise(async (resolve) => {
+                        try {
+                            await fs.mkdir(targetDir);
+                        }
+                        catch (e) { }
+                        resolve();
+                    }));
+                }
+            }
+            if (!this.stopped) {
+                await fs.put(from.path, (0, node_path_1.join)(targetDir, from.name));
+            }
+        }
+        catch (error) {
+            this.onError(error);
+        }
+        this.sendState(from.size);
+    }
+    async finalize() {
+        this.touched.set(this.dest, Promise.resolve());
+        await Promise.all(Array.from(this.touched.values()));
+        Array.from(this.touched.keys()).forEach(path => this.watcher.refresh((0, URI_1.createURI)(this.to, path)));
+    }
+}
+exports.default = UploadQueue;

package/dist/transform.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.add = add;
+exports.remove = remove;
+exports.default = default_1;
+const uniqid_1 = __importDefault(require("./utils/uniqid"));
+const transformations = [];
+function add(f) {
+    const id = (0, uniqid_1.default)();
+    transformations.push({ id, f });
+    return id;
+}
+function remove(id) {
+    const i = transformations.findIndex(t => t.id == id);
+    if (i >= 0) {
+        transformations.splice(i, 1);
+    }
+}
+function default_1(files) {
+    return transformations.reduce((files, { f }) => f(files), files);
+}

package/dist/types.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FailureType = exports.QueueActionType = exports.QueueEventType = exports.QueueType = exports.SortOrder = exports.FileTagsAttr = exports.FileState = exports.FileStateAttr = exports.LocalFileSystemID = void 0;
+exports.LocalFileSystemID = 'file://';
+exports.FileStateAttr = Symbol.for('state');
+var FileState;
+(function (FileState) {
+    FileState["Creating"] = "creating";
+    FileState["Renaming"] = "renaming";
+})(FileState || (exports.FileState = FileState = {}));
+exports.FileTagsAttr = Symbol.for('tags');
+var SortOrder;
+(function (SortOrder) {
+    SortOrder["Asc"] = "asc";
+    SortOrder["Desc"] = "desc";
+})(SortOrder || (exports.SortOrder = SortOrder = {}));
+var QueueType;
+(function (QueueType) {
+    QueueType["Copy"] = "copy";
+    QueueType["Move"] = "move";
+    QueueType["Download"] = "download";
+    QueueType["Upload"] = "upload";
+    QueueType["Remove"] = "remove";
+})(QueueType || (exports.QueueType = QueueType = {}));
+var QueueEventType;
+(function (QueueEventType) {
+    QueueEventType["Create"] = "create";
+    QueueEventType["Update"] = "update";
+    QueueEventType["Ask"] = "ask";
+    QueueEventType["Complete"] = "complete";
+})(QueueEventType || (exports.QueueEventType = QueueEventType = {}));
+var QueueActionType;
+(function (QueueActionType) {
+    QueueActionType["Skip"] = "skip";
+    QueueActionType["Replace"] = "replace";
+    QueueActionType["Rename"] = "rename";
+})(QueueActionType || (exports.QueueActionType = QueueActionType = {}));
+var FailureType;
+(function (FailureType) {
+    FailureType["Unauthorized"] = "unauthorized";
+    FailureType["ConfirmDeletion"] = "confirm-deletion";
+    FailureType["ConfirmClear"] = "confirm-clear";
+    FailureType["MissingDir"] = "missing-dir";
+    FailureType["RemoteError"] = "remote-error";
+    FailureType["APIError"] = "api-error";
+})(FailureType || (exports.FailureType = FailureType = {}));

package/dist/utils/ReferenceCountMap.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class default_1 {
+    constructor() {
+        this.entries = new Map;
+    }
+    set(key, value) {
+        const found = this.entries.get(key);
+        this.entries.set(key, found ? { count: ++found.count, value } : { count: 1, value });
+        return this;
+    }
+    has(key) {
+        return this.entries.has(key);
+    }
+    get(key) {
+        return this.entries.get(key)?.value;
+    }
+    inc(key) {
+        const found = this.entries.get(key);
+        return found ? ++found.count : 0;
+    }
+    dec(key) {
+        const found = this.entries.get(key);
+        if (found) {
+            if (--found.count <= 0) {
+                this.entries.delete(key);
+                return found.value;
+            }
+        }
+        return undefined;
+    }
+    del(key) {
+        const found = this.entries.get(key);
+        found && this.entries.delete(key);
+        return found?.value;
+    }
+    count(key) {
+        return this.entries.get(key)?.count;
+    }
+    modify(key, value) {
+        const found = this.entries.get(key);
+        if (found) {
+            found.value = value;
+            return true;
+        }
+        return false;
+    }
+    keys() {
+        return this.entries.keys();
+    }
+    renameKey(from, to) {
+        if (!this.entries.has(from)) {
+            return;
+        }
+        this.entries.has(to) ?
+            this.entries.get(to).count += this.entries.get(from).count :
+            this.entries.set(to, this.entries.get(from));
+        this.entries.delete(from);
+    }
+}
+exports.default = default_1;