@maiyunnet/kebab 2.0.0

package/lib/fs.js

@@ -0,0 +1,405 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContent = getContent;
+exports.putContent = putContent;
+exports.readLink = readLink;
+exports.symlink = symlink;
+exports.unlink = unlink;
+exports.stats = stats;
+exports.isDir = isDir;
+exports.isFile = isFile;
+exports.mkdir = mkdir;
+exports.rmdir = rmdir;
+exports.rmdirDeep = rmdirDeep;
+exports.chmod = chmod;
+exports.rename = rename;
+exports.readDir = readDir;
+exports.copyFolder = copyFolder;
+exports.copyFile = copyFile;
+exports.createReadStream = createReadStream;
+exports.pipe = pipe;
+exports.createWriteStream = createWriteStream;
+exports.readToResponse = readToResponse;
+const fs = __importStar(require("fs"));
+const http2 = __importStar(require("http2"));
+const mime = __importStar(require("@litert/mime"));
+const text = __importStar(require("./text"));
+const core = __importStar(require("./core"));
+const zlib = __importStar(require("./zlib"));
+async function getContent(path, options) {
+    if (typeof options === 'string') {
+        options = {
+            'encoding': options
+        };
+    }
+    else if (!options) {
+        options = {};
+    }
+    const encoding = options.encoding;
+    const start = options.start;
+    const end = options.end;
+    if (start ?? end) {
+        return new Promise(function (resolve) {
+            const rs = createReadStream(path, {
+                'encoding': encoding,
+                'start': start,
+                'end': end
+            });
+            const data = [];
+            rs.on('data', (chunk) => {
+                if (!(chunk instanceof Buffer)) {
+                    return;
+                }
+                data.push(chunk);
+            }).on('end', function () {
+                const buf = Buffer.concat(data);
+                if (encoding) {
+                    resolve(buf.toString());
+                }
+                else {
+                    resolve(buf);
+                }
+            }).on('error', function () {
+                resolve(null);
+            });
+        });
+    }
+    else {
+        try {
+            if (encoding) {
+                return await fs.promises.readFile(path, {
+                    'encoding': encoding
+                });
+            }
+            else {
+                return await fs.promises.readFile(path);
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+}
+async function putContent(path, data, options = {}) {
+    try {
+        await fs.promises.writeFile(path, data, options);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readLink(path, encoding) {
+    try {
+        return await fs.promises.readlink(path, {
+            'encoding': encoding
+        });
+    }
+    catch {
+        return null;
+    }
+}
+async function symlink(filePath, linkPath, type) {
+    try {
+        await fs.promises.symlink(filePath, linkPath, type);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function unlink(path) {
+    for (let i = 0; i <= 2; ++i) {
+        try {
+            await fs.promises.unlink(path);
+            return true;
+        }
+        catch {
+            await core.sleep(250);
+        }
+    }
+    try {
+        await fs.promises.unlink(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function stats(path) {
+    try {
+        return await fs.promises.lstat(path);
+    }
+    catch {
+        return null;
+    }
+}
+async function isDir(path) {
+    const pstats = await stats(path);
+    if (!pstats?.isDirectory()) {
+        return false;
+    }
+    return pstats;
+}
+async function isFile(path) {
+    const pstats = await stats(path);
+    if (!pstats?.isFile()) {
+        return false;
+    }
+    return pstats;
+}
+async function mkdir(path, mode = 0o755) {
+    if (await isDir(path)) {
+        return true;
+    }
+    try {
+        await fs.promises.mkdir(path, {
+            'recursive': true,
+            'mode': mode
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function rmdir(path) {
+    if (!(await isDir(path))) {
+        return true;
+    }
+    try {
+        await fs.promises.rmdir(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function rmdirDeep(path) {
+    if (!path.endsWith('/')) {
+        path += '/';
+    }
+    const list = await readDir(path);
+    for (const item of list) {
+        const stat = await stats(item.name);
+        if (!stat) {
+            return false;
+        }
+        if (stat.isDirectory()) {
+            const rtn = await rmdirDeep(path + item.name);
+            if (!rtn) {
+                return false;
+            }
+        }
+        else {
+            const rtn = await unlink(path + item.name);
+            if (!rtn) {
+                return false;
+            }
+        }
+    }
+    return rmdir(path);
+}
+async function chmod(path, mod) {
+    try {
+        await fs.promises.chmod(path, mod);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function rename(oldPath, newPath) {
+    try {
+        await fs.promises.rename(oldPath, newPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readDir(path, encoding) {
+    try {
+        const list = [];
+        const dlist = await fs.promises.readdir(path, {
+            'encoding': encoding,
+            'withFileTypes': true
+        });
+        for (const item of dlist) {
+            if (item.name === '.' || item.name === '..') {
+                continue;
+            }
+            list.push(item);
+        }
+        return list;
+    }
+    catch {
+        return [];
+    }
+}
+async function copyFolder(from, to, ignore = []) {
+    let num = 0;
+    if (!await isDir(from)) {
+        return 0;
+    }
+    const flist = await readDir(from);
+    let checkTo = false;
+    for (const item of flist) {
+        if (item.isDirectory()) {
+            const r = await copyFolder(from + item.name + '/', to + item.name + '/', ignore);
+            if (r === -1) {
+                return r;
+            }
+            else {
+                num += r;
+            }
+        }
+        else if (item.isFile()) {
+            if (ignore.length > 0 && text.match(item.name, ignore)) {
+                continue;
+            }
+            if (!checkTo) {
+                if (!await mkdir(to)) {
+                    return -1;
+                }
+                checkTo = true;
+            }
+            if (!(await copyFile(from + item.name, to + item.name))) {
+                continue;
+            }
+            ++num;
+        }
+    }
+    return num;
+}
+async function copyFile(src, dest) {
+    try {
+        await fs.promises.copyFile(src, dest);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function createReadStream(path, options) {
+    if (typeof options === 'string') {
+        options = {
+            'encoding': options
+        };
+    }
+    else if (!options) {
+        options = {};
+    }
+    return fs.createReadStream(path, {
+        'flags': options.flags,
+        'encoding': options.encoding,
+        'autoClose': options.autoClose,
+        'start': options.start,
+        'end': options.end
+    });
+}
+function pipe(path, destination, options) {
+    return new Promise((resolve) => {
+        createReadStream(path).on('error', function () {
+            resolve(false);
+        }).on('end', function () {
+            resolve(true);
+        }).pipe(destination, options);
+    });
+}
+function createWriteStream(path, options) {
+    if (typeof options === 'string') {
+        options = {
+            'encoding': options
+        };
+    }
+    else if (!options) {
+        options = {};
+    }
+    return fs.createWriteStream(path, {
+        'flags': options.flags,
+        'encoding': options.encoding,
+        'mode': options.mode,
+        'autoClose': options.autoClose,
+        'start': options.start
+    });
+}
+async function readToResponse(path, req, res, stat) {
+    if (!stat) {
+        stat = await stats(path);
+    }
+    if (!stat) {
+        res.setHeader('content-length', 22);
+        res.writeHead(404);
+        res.end('<h1>404 Not found</h1><hr>Kebab');
+        return;
+    }
+    let charset = '';
+    const mimeData = mime.getData(path);
+    if (['htm', 'html', 'css', 'js', 'xml', 'jpg', 'jpeg', 'svg', 'gif', 'png'].includes(mimeData.extension)) {
+        charset = '; charset=utf-8';
+        const hash = `W/"${stat.size.toString(16)}-${stat.mtime.getTime().toString(16)}"`;
+        const lastModified = stat.mtime.toUTCString();
+        res.setHeader('etag', hash);
+        res.setHeader('cache-control', 'public, max-age=600');
+        const noneMatch = req.headers['if-none-match'];
+        const modifiedSince = req.headers['if-modified-since'];
+        if ((hash === noneMatch) && (lastModified === modifiedSince)) {
+            res.writeHead(304);
+            res.end();
+            return;
+        }
+        res.setHeader('last-modified', lastModified);
+    }
+    else {
+        res.setHeader('cache-control', 'no-cache, must-revalidate');
+    }
+    res.setHeader('content-type', mimeData.mime + charset);
+    const encoding = req.headers['accept-encoding'] ?? '';
+    if (mimeData.compressible && (stat.size >= 1024)) {
+        const compress = await zlib.compress(encoding, await getContent(path));
+        if (compress) {
+            res.setHeader('content-encoding', compress.type);
+            res.setHeader('content-length', Buffer.byteLength(compress.buffer));
+            res.writeHead(200);
+            res.end(compress.buffer);
+            return;
+        }
+    }
+    res.setHeader('content-length', stat.size);
+    res.writeHead(200);
+    await pipe(path, res instanceof http2.Http2ServerResponse ? (res.stream ?? res) : res);
+}