hfs 0.1.6 → 0.26.2

package/src/update.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.update = exports.getUpdate = void 0;
+const github_1 = require("./github");
+const const_1 = require("./const");
+const path_1 = require("path");
+const child_process_1 = require("child_process");
+const misc_1 = require("./misc");
+const fs_1 = require("fs");
+const plugins_1 = require("./plugins");
+const promises_1 = require("fs/promises");
+const HFS_REPO = 'rejetto/hfs';
+async function getUpdate() {
+    const [latest] = await (0, github_1.getRepoInfo)(HFS_REPO + '/releases?per_page=1');
+    if (latest.name === const_1.VERSION)
+        throw "you already have the latest version: " + const_1.VERSION;
+    return latest;
+}
+exports.getUpdate = getUpdate;
+async function update() {
+    if (process.argv0.endsWith('node'))
+        throw "only binary versions are supported for now";
+    const update = await getUpdate();
+    const assetSearch = { win32: 'windows', darwin: 'mac', linux: 'linux' }[process.platform];
+    if (!assetSearch)
+        throw "this feature doesn't support your platform: " + process.platform;
+    const asset = update.assets.find((x) => x.name.endsWith('.zip') && x.name.includes(assetSearch));
+    if (!asset)
+        throw "asset not found";
+    const url = asset.browser_download_url;
+    console.log("downloading", url);
+    const bin = process.argv[0];
+    const binPath = (0, path_1.dirname)(bin);
+    const binFile = (0, path_1.basename)(bin);
+    const newBinFile = 'new-' + binFile;
+    plugins_1.pluginsWatcher.pause();
+    try {
+        await (0, misc_1.unzip)(await (0, misc_1.httpsStream)(url), path => (0, path_1.join)(binPath, path === binFile ? newBinFile : path));
+        const newBin = (0, path_1.join)(binPath, newBinFile);
+        if (!const_1.IS_WINDOWS) {
+            const { mode } = await (0, promises_1.stat)(bin);
+            await (0, promises_1.chmod)(newBin, mode).catch(console.error);
+        }
+        (0, misc_1.onProcessExit)(() => {
+            const oldBinFile = 'old-' + binFile;
+            console.log("old version is kept as", oldBinFile);
+            const oldBin = (0, path_1.join)(binPath, oldBinFile);
+            try {
+                (0, fs_1.unlinkSync)(oldBin);
+            }
+            catch (_a) { }
+            (0, fs_1.renameSync)(bin, oldBin);
+            console.log("launching new version in background", newBinFile);
+            (0, child_process_1.spawn)(newBin, ['--updating', binFile], { detached: true, shell: true })
+                .on('error', console.error);
+        });
+        console.log('quitting');
+        process.exit();
+    }
+    catch (_a) {
+        plugins_1.pluginsWatcher.unpause();
+    }
+}
+exports.update = update;
+if (const_1.argv.updating) { // we were launched with a temporary name, restore original name to avoid breaking references
+    const bin = process.argv[0];
+    (0, fs_1.renameSync)(bin, (0, path_1.join)((0, path_1.dirname)(bin), const_1.argv.updating));
+    console.log("renamed binary file to", const_1.argv.updating);
+}

package/src/util-files.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unzip = exports.run = exports.dirStream = exports.isWindowsDrive = exports.dirTraversal = exports.watchDir = exports.readFileBusy = exports.isFile = exports.isDirectory = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const misc_1 = require("./misc");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const const_1 = require("./const");
+const child_process_1 = require("child_process");
+const stream_1 = require("stream");
+// @ts-ignore
+const unzip_stream_1 = __importDefault(require("unzip-stream"));
+async function isDirectory(path) {
+    try {
+        return (await promises_1.default.stat(path)).isDirectory();
+    }
+    catch (_a) {
+        return false;
+    }
+}
+exports.isDirectory = isDirectory;
+async function isFile(path) {
+    try {
+        return (await promises_1.default.stat(path)).isFile();
+    }
+    catch (_a) {
+        return false;
+    }
+}
+exports.isFile = isFile;
+async function readFileBusy(path) {
+    return promises_1.default.readFile(path, 'utf8').catch(e => {
+        if ((e === null || e === void 0 ? void 0 : e.code) !== 'EBUSY')
+            throw e;
+        console.debug('busy');
+        return (0, misc_1.wait)(100).then(() => readFileBusy(path));
+    });
+}
+exports.readFileBusy = readFileBusy;
+function watchDir(dir, cb) {
+    let watcher;
+    let paused = false;
+    try {
+        watcher = (0, fs_1.watch)(dir, controlledCb);
+    }
+    catch (_a) {
+        // failing watching the content of the dir, we try to monitor its parent, but filtering events only for our target dir
+        const base = (0, path_1.basename)(dir);
+        try {
+            watcher = (0, fs_1.watch)((0, path_1.dirname)(dir), (event, name) => {
+                if (name !== base)
+                    return;
+                try {
+                    watcher.close(); // if we succeed, we give up the parent watching
+                    watcher = (0, fs_1.watch)(dir, controlledCb); // attempt at passing to a more specific watching
+                }
+                catch (_a) { }
+                controlledCb();
+            });
+        }
+        catch (e) {
+            console.debug(String(e));
+        }
+    }
+    return {
+        working() { return Boolean(watcher); },
+        stop() { watcher === null || watcher === void 0 ? void 0 : watcher.close(); },
+        pause() { paused = true; },
+        unpause() { paused = false; },
+    };
+    function controlledCb() {
+        if (!paused)
+            cb();
+    }
+}
+exports.watchDir = watchDir;
+function dirTraversal(s) {
+    return s && /(^|[/\\])\.\.($|[/\\])/.test(s);
+}
+exports.dirTraversal = dirTraversal;
+function isWindowsDrive(s) {
+    return s && /^[a-zA-Z]:$/.test(s);
+}
+exports.isWindowsDrive = isWindowsDrive;
+async function* dirStream(path) {
+    const stats = await promises_1.default.stat(path);
+    if (!stats.isDirectory())
+        throw Error('ENOTDIR');
+    const dirStream = fast_glob_1.default.stream('*', {
+        cwd: path,
+        dot: true,
+        onlyFiles: false,
+        suppressErrors: true,
+    });
+    const skip = await getItemsToSkip(path);
+    for await (let path of dirStream) {
+        if (path instanceof Buffer)
+            path = path.toString('utf8');
+        if (skip === null || skip === void 0 ? void 0 : skip.includes(path))
+            continue;
+        yield path;
+    }
+    async function getItemsToSkip(path) {
+        if (!const_1.IS_WINDOWS)
+            return;
+        const out = await run('dir', ['/ah', '/b', path.replace(/\//g, '\\')])
+            .catch(() => ''); // error in case of no matching file
+        return out.split('\r\n').slice(0, -1);
+    }
+}
+exports.dirStream = dirStream;
+function run(cmd, args = []) {
+    return new Promise((resolve, reject) => (0, child_process_1.execFile)('cmd', ['/c', cmd, ...args], (err, stdout) => {
+        if (err)
+            reject(err);
+        else
+            resolve(stdout);
+    }));
+}
+exports.run = run;
+async function unzip(stream, cb) {
+    let pending = Promise.resolve();
+    return new Promise(resolve => stream.pipe(unzip_stream_1.default.Parse())
+        .on('end', () => pending.then(resolve))
+        .on('entry', async (entry) => {
+        const { path, type } = entry;
+        const dest = cb(path);
+        if (!dest || type !== 'File')
+            return entry.autodrain();
+        await pending; // don't overlap writings
+        console.debug('unzip', dest);
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(dest), { recursive: true }); // easy way be sure to have the folder ready before proceeding
+        const thisFile = entry.pipe((0, fs_1.createWriteStream)(dest));
+        pending = (0, stream_1.once)(thisFile, 'finish');
+    }));
+}
+exports.unzip = unzip;

package/src/util-generators.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncGeneratorToReadable = exports.asyncGeneratorToArray = exports.filterMapGenerator = void 0;
+// callback can return undefined to skip element
+const stream_1 = require("stream");
+async function* filterMapGenerator(generator, filterMap) {
+    for await (const x of generator) {
+        const res = await filterMap(x);
+        if (res !== undefined)
+            yield res;
+    }
+}
+exports.filterMapGenerator = filterMapGenerator;
+async function asyncGeneratorToArray(generator) {
+    const ret = [];
+    for await (const x of generator)
+        ret.push(x);
+    return ret;
+}
+exports.asyncGeneratorToArray = asyncGeneratorToArray;
+function asyncGeneratorToReadable(generator) {
+    const iterator = generator[Symbol.asyncIterator]();
+    return new stream_1.Readable({
+        objectMode: true,
+        read() {
+            iterator.next().then(it => this.push(it.done ? null : it.value));
+        }
+    });
+}
+exports.asyncGeneratorToReadable = asyncGeneratorToReadable;

package/src/util-http.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 });
+exports.httpsStream = exports.httpsString = void 0;
+const node_https_1 = __importDefault(require("node:https"));
+function httpsString(url, options = {}) {
+    return httpsStream(url, options).then(res => new Promise(resolve => {
+        let buf = '';
+        res.on('data', chunk => buf += chunk.toString());
+        res.on('end', () => resolve(Object.assign(res, {
+            ok: (res.statusCode || 400) < 400,
+            body: buf
+        })));
+    }));
+}
+exports.httpsString = httpsString;
+function httpsStream(url, options = {}) {
+    return new Promise((resolve, reject) => {
+        node_https_1.default.request(url, options, res => {
+            if (!res.statusCode || res.statusCode >= 400)
+                throw res;
+            if (res.statusCode === 302 && res.headers.location)
+                return resolve(httpsStream(res.headers.location, options));
+            resolve(res);
+        }).on('error', reject).end();
+    });
+}
+exports.httpsStream = httpsStream;

package/src/vfs.js

@@ -0,0 +1,227 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2022, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cantReadStatusCode = exports.walkNode = exports.hasPermission = exports.nodeIsDirectory = exports.getNodeName = exports.saveVfs = exports.vfs = exports.urlToNode = exports.MIME_AUTO = exports.defaultPerms = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = require("path");
+const micromatch_1 = require("micromatch");
+const misc_1 = require("./misc");
+const lodash_1 = __importDefault(require("lodash"));
+const config_1 = require("./config");
+const const_1 = require("./const");
+const events_1 = __importDefault(require("./events"));
+const perm_1 = require("./perm");
+const misc_2 = require("./misc");
+const WHO_ANYONE = true;
+const WHO_NO_ONE = false;
+const WHO_ANY_ACCOUNT = '*';
+exports.defaultPerms = {
+    can_see: WHO_ANYONE,
+    can_read: WHO_ANYONE,
+};
+exports.MIME_AUTO = 'auto';
+function inheritFromParent(parent, child) {
+    for (const k of (0, misc_1.typedKeys)(exports.defaultPerms)) {
+        const v = parent[k];
+        if (v !== undefined)
+            child[k] = v;
+    }
+    if (typeof parent.mime === 'object' && typeof child.mime === 'object')
+        Object.assign(child.mime, parent.mime);
+    else
+        child.mime = parent.mime;
+    return child;
+}
+async function urlToNode(url, ctx, parent = exports.vfs) {
+    var _a;
+    let i = url.indexOf('/', 1);
+    const name = decodeURIComponent(url.slice(url[0] === '/' ? 1 : 0, i < 0 ? undefined : i));
+    if (!name)
+        return parent;
+    const rest = i < 0 ? '' : url.slice(i + 1, url.endsWith('/') ? -1 : undefined);
+    if ((0, misc_1.dirTraversal)(name) || /[\/]/.test(name)) {
+        if (ctx)
+            ctx.status = 418;
+        return;
+    }
+    const parents = parent.parents || []; // don't waste time cloning the array, as we won't keep intermediate nodes
+    const ret = {
+        isTemp: true,
+        url: (0, misc_1.enforceFinal)('/', parent.url || '') + name,
+        parents,
+    };
+    parents.push(parent);
+    inheritFromParent(parent, ret);
+    inheritMasks(ret, parent, name);
+    applyMasks(ret, parent, name);
+    // does the tree node have a child that goes by this name?
+    const sameName = !const_1.IS_WINDOWS ? (x) => x === name // easy
+        : (0, misc_2.with_)(name.toLowerCase(), lc => (x) => x.toLowerCase() === lc);
+    const child = (_a = parent.children) === null || _a === void 0 ? void 0 : _a.find(x => sameName(getNodeName(x)));
+    if (child) // yes
+        return urlToNode(rest, ctx, Object.assign(ret, child, { original: child }));
+    // not in the tree, we can see consider continuing on the disk
+    if (!parent.source)
+        return; // but then we need the current node to be linked to the disk, otherwise, we give up
+    let onDisk = name;
+    if (parent.rename) { // reverse the mapping
+        for (const [from, to] of Object.entries(parent.rename))
+            if (name === to) {
+                onDisk = from;
+                break; // found, search no more
+            }
+        ret.rename = renameUnderPath(parent.rename, name);
+    }
+    ret.source = (0, misc_1.enforceFinal)('/', parent.source) + onDisk;
+    if (parent.default)
+        inheritFromParent({ mime: { '*': exports.MIME_AUTO } }, ret);
+    if (rest)
+        return urlToNode(rest, ctx, ret);
+    if (ret.source)
+        try {
+            await promises_1.default.stat(ret.source);
+        } // check existence
+        catch (_b) {
+            return;
+        }
+    return ret;
+}
+exports.urlToNode = urlToNode;
+exports.vfs = {};
+(0, config_1.defineConfig)('vfs', {}).sub(data => exports.vfs = data);
+function saveVfs() {
+    return (0, config_1.setConfig)({ vfs: lodash_1.default.cloneDeep(exports.vfs) }, true);
+}
+exports.saveVfs = saveVfs;
+function getNodeName(node) {
+    return node.name
+        || node.source && (/^[a-zA-Z]:\\?$/.test(node.source) && node.source.slice(0, 2)
+            || (0, path_1.basename)(node.source)
+            || node.source)
+        || ''; // should happen only for root
+}
+exports.getNodeName = getNodeName;
+async function nodeIsDirectory(node) {
+    return Boolean(!node.source || await (0, misc_1.isDirectory)(node.source));
+}
+exports.nodeIsDirectory = nodeIsDirectory;
+function hasPermission(node, perm, ctx) {
+    var _a;
+    return matchWho((_a = node[perm]) !== null && _a !== void 0 ? _a : exports.defaultPerms[perm], ctx)
+        && (perm !== 'can_see' || hasPermission(node, 'can_read', ctx)); // for can_see you must also can_read
+}
+exports.hasPermission = hasPermission;
+async function* walkNode(parent, ctx, depth = 0, prefixPath = '') {
+    const { children, source } = parent;
+    if (children)
+        for (let idx = 0; idx < children.length; idx++) {
+            const child = children[idx];
+            yield* workItem({
+                ...child,
+                name: prefixPath ? (prefixPath + getNodeName(child)) : child.name
+            });
+        }
+    if (!source)
+        return;
+    try {
+        for await (const path of (0, misc_1.dirStream)(source)) {
+            if (ctx.req.aborted)
+                return;
+            let { rename } = parent;
+            const renamed = rename === null || rename === void 0 ? void 0 : rename[path];
+            yield* workItem({
+                name: (prefixPath || renamed) && prefixPath + (renamed || path),
+                source: (0, path_1.join)(source, path),
+                rename: renameUnderPath(rename, path),
+            });
+        }
+    }
+    catch (e) {
+        console.debug('glob', source, e); // ENOTDIR, or lacking permissions
+    }
+    async function* workItem(item) {
+        // we basename for depth>0 where we already have the rest of the path in the parent's url, and would be duplicated
+        const name = (0, path_1.basename)(getNodeName(item));
+        const url = (0, misc_1.enforceFinal)('/', parent.url || '') + name;
+        const temp = inheritFromParent(parent, {
+            ...item,
+            isTemp: true,
+            url,
+            parents: [...parent.parents || [], parent],
+        });
+        applyMasks(temp, parent, name);
+        if (!hasPermission(temp, 'can_see', ctx))
+            return;
+        yield temp;
+        try {
+            if (!depth || !await nodeIsDirectory(temp))
+                return;
+            inheritMasks(temp, parent, name);
+            yield* walkNode(temp, ctx, depth - 1, getNodeName(temp) + '/');
+        }
+        catch (_a) { } // stat failed in nodeIsDirectory, ignore
+    }
+}
+exports.walkNode = walkNode;
+function applyMasks(item, parent, name) {
+    const { masks } = parent;
+    if (!masks)
+        return;
+    for (const k in masks)
+        if (k.startsWith('**/') && (0, micromatch_1.isMatch)(name, k.slice(3))
+            || !k.includes('/') && (0, micromatch_1.isMatch)(name, k))
+            Object.assign(item, masks[k]);
+}
+function inheritMasks(item, parent, name) {
+    const { masks } = parent;
+    if (!masks)
+        return;
+    const o = {};
+    for (const k in masks)
+        if (k.startsWith('**/'))
+            o[k.slice(3)] = masks[k];
+        else if (k.startsWith(name + '/'))
+            o[k.slice(name.length + 1)] = masks[k];
+    if (Object.keys(o).length)
+        item.masks = o;
+}
+function renameUnderPath(rename, path) {
+    if (!rename)
+        return rename;
+    const match = path + '/';
+    rename = Object.fromEntries(Object.entries(rename).map(([k, v]) => [k.startsWith(match) ? k.slice(match.length) : '', v]));
+    delete rename[''];
+    return lodash_1.default.isEmpty(rename) ? undefined : rename;
+}
+function matchWho(who, ctx) {
+    return who === WHO_ANYONE
+        || who === WHO_ANY_ACCOUNT && Boolean(ctx.state.account)
+        || Array.isArray(who) && (() => // check if I or any ancestor match `who`, but cache ancestors' usernames inside context state
+         (0, misc_1.getOrSet)(ctx.state, 'usernames', () => (0, perm_1.getCurrentUsernameExpanded)(ctx)).some((u) => who.includes(u)))();
+}
+function cantReadStatusCode(node) {
+    return node.can_read === false ? const_1.FORBIDDEN : const_1.UNAUTHORIZED;
+}
+exports.cantReadStatusCode = cantReadStatusCode;
+events_1.default.on('accountRenamed', (from, to) => {
+    recur(exports.vfs);
+    saveVfs();
+    function recur(n) {
+        var _a;
+        replace(n.can_see);
+        replace(n.can_read);
+        if (n.masks)
+            Object.values(n.masks).forEach(recur);
+        (_a = n.children) === null || _a === void 0 ? void 0 : _a.forEach(recur);
+    }
+    function replace(a) {
+        if (!Array.isArray(a))
+            return;
+        for (let i = 0; i < a.length; i++)
+            if (a[i] === from)
+                a[i] = to;
+    }
+});

package/src/watchLoad.js

@@ -0,0 +1,73 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2022, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchLoad = void 0;
+const fs_1 = require("fs");
+const promises_1 = __importDefault(require("fs/promises"));
+const yaml_1 = __importDefault(require("yaml"));
+const misc_1 = require("./misc");
+function watchLoad(path, parser, { failedOnFirstAttempt } = {}) {
+    let doing = false;
+    let watcher;
+    const debounced = (0, misc_1.debounceAsync)(load, 500, { leading: true });
+    let retry;
+    let saving;
+    let lastStats;
+    init().then(ok => ok || (failedOnFirstAttempt === null || failedOnFirstAttempt === void 0 ? void 0 : failedOnFirstAttempt()));
+    return {
+        unwatch() {
+            watcher === null || watcher === void 0 ? void 0 : watcher.close();
+            clearTimeout(retry);
+            watcher = undefined;
+        },
+        save(...args) {
+            return Promise.resolve(saving).then(() => // wait in case another is ongoing
+             saving = promises_1.default.writeFile(...args).finally(() => // save but also keep track of the current operation
+             saving = undefined)); // clear
+        }
+    };
+    async function init() {
+        try {
+            debounced().then();
+            watcher = (0, fs_1.watch)(path, () => {
+                if (!saving)
+                    debounced().then();
+            });
+            return true; // used actually just by the first invocation
+        }
+        catch (e) {
+            retry = setTimeout(init, 3000); // manual watching until watch is successful
+        }
+    }
+    async function load() {
+        if (doing)
+            return;
+        doing = true;
+        let data;
+        try {
+            try { // I've seen watch() firing 'change' without any change, so we'll check if any change is detectable before going on
+                const stats = await promises_1.default.stat(path);
+                if (stats.mtimeMs === (lastStats === null || lastStats === void 0 ? void 0 : lastStats.mtimeMs))
+                    return;
+                lastStats = stats;
+                data = await (0, misc_1.readFileBusy)(path);
+                console.debug('loaded', path);
+            }
+            catch (e) {
+                if (e.code === 'EPERM')
+                    console.error("missing permissions on file", path); // warn user, who could be clueless about this problem
+                return; // ignore read errors
+            }
+            if (path.endsWith('.yaml'))
+                data = yaml_1.default.parse(data);
+            await parser(data);
+        }
+        finally {
+            doing = false;
+        }
+    }
+}
+exports.watchLoad = watchLoad;

package/src/zip.js

@@ -0,0 +1,69 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2022, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zipStreamFromFolder = void 0;
+const vfs_1 = require("./vfs");
+const misc_1 = require("./misc");
+const QuickZipStream_1 = require("./QuickZipStream");
+const fs_1 = require("fs");
+const promises_1 = __importDefault(require("fs/promises"));
+const config_1 = require("./config");
+const path_1 = require("path");
+const serveFile_1 = require("./serveFile");
+async function zipStreamFromFolder(node, ctx) {
+    ctx.status = 200;
+    ctx.mime = 'zip';
+    const name = (0, vfs_1.getNodeName)(node);
+    ctx.attachment((name || 'archive') + '.zip');
+    const filter = (0, misc_1.pattern2filter)(String(ctx.query.search || ''));
+    const { list } = ctx.query;
+    const walker = !list ? (0, vfs_1.walkNode)(node, ctx, Infinity)
+        : (async function* () {
+            for await (const el of String(list).split('*')) { // we are using * as separator because it cannot be used in a file name and doesn't need url encoding
+                const subNode = await (0, vfs_1.urlToNode)(el, ctx, node);
+                if (!subNode || !(0, vfs_1.hasPermission)(subNode, 'can_read', ctx))
+                    continue;
+                if (await (0, vfs_1.nodeIsDirectory)(subNode)) { // a directory needs to walked
+                    yield* (0, vfs_1.walkNode)(subNode, ctx, Infinity, el + '/');
+                    continue;
+                }
+                let folder = (0, path_1.dirname)(el);
+                folder = folder === '.' ? '' : folder + '/';
+                yield { ...subNode, name: folder + (0, vfs_1.getNodeName)(subNode) }; // reflect relative path in archive, otherwise way may have name-clashes
+            }
+        })();
+    const mappedWalker = (0, misc_1.filterMapGenerator)(walker, async (el) => {
+        const { source } = el;
+        const name = (0, vfs_1.getNodeName)(el);
+        if (!source || ctx.req.aborted || !filter(name))
+            return;
+        try {
+            const st = await promises_1.default.stat(source);
+            if (!st || !st.isFile())
+                return;
+            return {
+                path: name,
+                size: st.size,
+                ts: st.mtime || st.ctime,
+                mode: st.mode,
+                sourcePath: source,
+                getData: () => (0, fs_1.createReadStream)(source, { start: 0, end: Math.max(0, st.size - 1) })
+            };
+        }
+        catch (_a) { }
+    });
+    const zip = new QuickZipStream_1.QuickZipStream(mappedWalker);
+    const time = 1000 * zipSeconds.get();
+    ctx.response.length = await zip.calculateSize(time);
+    const range = (0, serveFile_1.getRange)(ctx, ctx.response.length);
+    if (range)
+        zip.applyRange(range.start, range.end);
+    ctx.body = zip;
+    ctx.req.on('close', () => zip.destroy());
+    ctx.state.archive = 'zip';
+}
+exports.zipStreamFromFolder = zipStreamFromFolder;
+const zipSeconds = (0, config_1.defineConfig)('zip_calculate_size_for_seconds', 1);

package/.npmignore

@@ -1,19 +0,0 @@
-lib-cov
-*.seed
-*.log
-*.csv
-*.dat
-*.out
-*.pid
-*.gz
-*.lnk
-dbg.txt
-run.bat
-
-temp
-pids
-logs
-results
-
-node_modules
-npm-debug.log