link-unlink/dist/cjs/unlink.js

Link and unlink with saving and restoring the previous file or directory

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
Object.defineProperty(exports, "default", {
    enumerable: true,
    get: function() {
        return unlink;
    }
});
var _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
var _fsremovecompat = require("fs-remove-compat");
var _lock = require("lock");
var _path = /*#__PURE__*/ _interop_require_default(require("path"));
var _queuecb = /*#__PURE__*/ _interop_require_default(require("queue-cb"));
function _interop_require_default(obj) {
    return obj && obj.__esModule ? obj : {
        default: obj
    };
}
var lock = (0, _lock.Lock)();
function restoreLink(previous, target, callback) {
    (0, _fsremovecompat.safeRm)(target, function(err) {
        err ? callback(err) : _fs.default.rename(previous, target, callback);
    });
}
function worker(target, callback) {
    lock(target, function(release) {
        callback = release(callback);
        var dirname = _path.default.dirname(target);
        var basename = _path.default.basename(target);
        _fs.default.readdir(dirname, function(err, files) {
            if (err) return callback(err);
            var matches = files.filter(function(x) {
                return x.indexOf(basename) === 0 && x.slice(basename.length)[0] === '.';
            }).map(function(x) {
                return _path.default.join(dirname, x);
            });
            if (matches.length === 0) return (0, _fsremovecompat.safeRm)(target, callback);
            if (matches.length === 1) return restoreLink(matches[0], target, callback);
            var stats = [];
            var queue = new _queuecb.default();
            matches.forEach(function(match) {
                queue.defer(function(cb) {
                    _fs.default.lstat(match, function(err, stat) {
                        if (err) return callback(err);
                        stats.push({
                            match: match,
                            stat: stat
                        });
                        cb();
                    });
                });
            });
            queue.await(function(err) {
                if (err) return callback(err);
                var sorted = stats.sort(function(a, b) {
                    return b.stat.ctime.valueOf() - a.stat.ctime.valueOf();
                });
                restoreLink(sorted[0].match, target, callback);
            });
        });
    });
}
function unlink(target, callback) {
    if (typeof callback === 'function') return worker(target, callback);
    return new Promise(function(resolve, reject) {
        return worker(target, function(err, restore) {
            return err ? reject(err) : resolve(restore);
        });
    });
}
/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }