@maiyunnet/kebab 2.0.0

package/lib/zip.js

@@ -0,0 +1,381 @@
+"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.Zip = void 0;
+exports.get = get;
+const jszip_1 = __importDefault(require("jszip"));
+const mime = __importStar(require("@litert/mime"));
+const lText = __importStar(require("~/lib/text"));
+class Zip {
+    constructor(zip) {
+        this._path = '/';
+        this._list = {};
+        this._zip = zip;
+        this._refreshList();
+    }
+    async getContent(path, type = 'string') {
+        path = lText.urlResolve(this._path, path);
+        const f = this._zip.file(path.slice(1));
+        if (!f) {
+            return null;
+        }
+        if (type === 'string') {
+            return f.async('string');
+        }
+        else {
+            return f.async(type);
+        }
+    }
+    putContent(path, data, options = {}) {
+        path = lText.urlResolve(this._path, path);
+        this._zip.file(path.slice(1), data, {
+            'base64': options.base64,
+            'binary': options.binary,
+            'date': options.date
+        });
+        this._refreshList();
+    }
+    unlink(path) {
+        path = lText.urlResolve(this._path, path);
+        this._zip.remove(path.slice(1));
+        this._refreshList();
+    }
+    stats(path) {
+        path = lText.urlResolve(this._path, path);
+        let dirpath = path.endsWith('/') ? path : path + '/';
+        if (!this._list[dirpath]) {
+            if (path.endsWith('/')) {
+                return null;
+            }
+            const lio = path.lastIndexOf('/') + 1;
+            const dpath = path.slice(0, lio);
+            const fname = path.slice(lio);
+            if (!this._list[dpath]) {
+                return null;
+            }
+            const file = this._list[dpath][fname];
+            if (!file) {
+                return null;
+            }
+            return {
+                'compressedSize': file.compressedSize,
+                'uncompressedSize': file.uncompressedSize,
+                'date': file.date,
+                'isFile': true,
+                'isDirectory': false
+            };
+        }
+        else {
+            if (dirpath === '/') {
+                return {
+                    'compressedSize': 0,
+                    'uncompressedSize': 0,
+                    'date': new Date(),
+                    'isFile': false,
+                    'isDirectory': true
+                };
+            }
+            dirpath = dirpath.slice(0, -1);
+            const lio = dirpath.lastIndexOf('/') + 1;
+            const dpath = dirpath.slice(0, lio);
+            const fname = dirpath.slice(lio);
+            const pfolder = this._list[dpath];
+            const folder = pfolder[fname];
+            return {
+                'compressedSize': 0,
+                'uncompressedSize': 0,
+                'date': folder.date,
+                'isFile': false,
+                'isDirectory': true
+            };
+        }
+    }
+    isDir(path) {
+        const pstats = this.stats(path);
+        if (!pstats?.isDirectory) {
+            return false;
+        }
+        return pstats;
+    }
+    isFile(path) {
+        const pstats = this.stats(path);
+        if (!pstats?.isFile) {
+            return false;
+        }
+        return pstats;
+    }
+    readDir(path, opt = {}) {
+        if (opt.hasChildren === undefined) {
+            opt.hasChildren = false;
+        }
+        if (opt.hasDir === undefined) {
+            opt.hasDir = true;
+        }
+        if (opt.pathAsKey === undefined) {
+            opt.pathAsKey = false;
+        }
+        if (!path) {
+            path = this._path;
+        }
+        else {
+            path = lText.urlResolve(this._path, path);
+        }
+        if (!path.endsWith('/')) {
+            path += '/';
+        }
+        const folder = this._zip.folder(path.slice(1));
+        if (!folder) {
+            return opt.pathAsKey ? {} : [];
+        }
+        if (!this._list[path]) {
+            return opt.pathAsKey ? {} : [];
+        }
+        if (!opt.hasChildren) {
+            if (opt.pathAsKey) {
+                return this._list[path];
+            }
+            const list = [];
+            for (const k in this._list[path]) {
+                list.push(this._list[path][k]);
+            }
+            return list;
+        }
+        if (opt.pathAsKey) {
+            const list = {};
+            for (const k in this._list[path]) {
+                const item = this._list[path][k];
+                if (item.isFile || opt.hasDir) {
+                    list[item.path + item.name] = item;
+                }
+                if (item.isDirectory) {
+                    Object.assign(list, this._readDir(item, {
+                        'hasDir': opt.hasDir,
+                        'pathAsKey': opt.pathAsKey
+                    }));
+                }
+            }
+            return list;
+        }
+        else {
+            let list = [];
+            for (const k in this._list[path]) {
+                const item = this._list[path][k];
+                if (item.isFile || opt.hasDir) {
+                    list.push(item);
+                }
+                if (item.isDirectory) {
+                    list = list.concat(this._readDir(item, {
+                        'hasDir': opt.hasDir,
+                        'pathAsKey': opt.pathAsKey
+                    }));
+                }
+            }
+            return list;
+        }
+    }
+    _readDir(item, opt) {
+        if (opt.pathAsKey) {
+            const list = {};
+            if (!this._list[item.path + item.name + '/']) {
+                return {};
+            }
+            for (const k in this._list[item.path + item.name + '/']) {
+                const it = this._list[item.path + item.name + '/'][k];
+                if (it.isFile || opt.hasDir) {
+                    list[it.path + it.name] = it;
+                }
+                if (it.isDirectory) {
+                    Object.assign(list, this._readDir(it, {
+                        'hasDir': opt.hasDir,
+                        'pathAsKey': opt.pathAsKey
+                    }));
+                }
+            }
+            return list;
+        }
+        else {
+            let list = [];
+            if (!this._list[item.path + item.name + '/']) {
+                return [];
+            }
+            for (const k in this._list[item.path + item.name + '/']) {
+                const it = this._list[item.path + item.name + '/'][k];
+                if (it.isFile || opt.hasDir) {
+                    list.push(it);
+                }
+                if (it.isDirectory) {
+                    list = list.concat(this._readDir(it, {
+                        'hasDir': opt.hasDir,
+                        'pathAsKey': opt.pathAsKey
+                    }));
+                }
+            }
+            return list;
+        }
+    }
+    _refreshList() {
+        const list = {};
+        this._zip.forEach(function (relativePath, item) {
+            if (relativePath.startsWith('/')) {
+                relativePath = relativePath.slice(1);
+            }
+            let parentPath = '/';
+            let name = '';
+            let s;
+            if (item.dir) {
+                s = relativePath.slice(0, -1).lastIndexOf('/');
+            }
+            else {
+                s = relativePath.lastIndexOf('/');
+            }
+            if (s !== -1) {
+                parentPath = '/' + relativePath.slice(0, s + 1);
+                name = relativePath.slice(s + 1);
+            }
+            else {
+                name = relativePath;
+            }
+            if (item.dir) {
+                name = name.slice(0, -1);
+            }
+            if (!list[parentPath]) {
+                list[parentPath] = {};
+            }
+            list[parentPath][name] = {
+                'name': name,
+                'compressedSize': item._data.compressedSize ?? 0,
+                'uncompressedSize': item._data.uncompressedSize ?? 0,
+                'date': item.date,
+                'isFile': !item.dir,
+                'isDirectory': item.dir,
+                'path': parentPath
+            };
+        });
+        this._list = list;
+    }
+    pwd() {
+        return this._path.slice(0, -1);
+    }
+    cd(dir) {
+        this._path = lText.urlResolve(this._path, dir);
+        if (!this._path.endsWith('/')) {
+            this._path += '/';
+        }
+        return this._path;
+    }
+    generate(options = {}) {
+        const opt = {};
+        if (options.type === undefined) {
+            opt.type = 'nodebuffer';
+        }
+        else {
+            opt.type = options.type;
+        }
+        if (options.level === undefined) {
+            options.level = 9;
+        }
+        else if (options.level > 9) {
+            options.level = 9;
+        }
+        if (options.level > 0) {
+            opt.compression = 'DEFLATE';
+        }
+        return this._zip.generateAsync(opt, function (meta) {
+            options.onUpdate?.(meta.percent, meta.currentFile);
+        });
+    }
+    getList() {
+        return new Promise((resolve) => {
+            const files = {};
+            const list = this.readDir('/', {
+                'hasChildren': true,
+                'hasDir': false
+            });
+            let loaded = 0;
+            for (const file of list) {
+                const mim = mime.getData(file.name);
+                if (['txt', 'json', 'js', 'css', 'xml', 'html'].includes(mim.extension)) {
+                    this.getContent(file.path + file.name, 'string').then(function (fb) {
+                        if (fb) {
+                            files[file.path + file.name] = fb;
+                        }
+                        ++loaded;
+                        if (loaded === list.length) {
+                            resolve(files);
+                        }
+                    }).catch(function () {
+                        ++loaded;
+                        if (loaded === list.length) {
+                            resolve(files);
+                        }
+                    });
+                }
+                else {
+                    this.getContent(file.path + file.name, 'nodebuffer').then(function (fb) {
+                        if (fb) {
+                            files[file.path + file.name] = fb;
+                        }
+                        ++loaded;
+                        if (loaded === list.length) {
+                            resolve(files);
+                        }
+                    }).catch(function () {
+                        ++loaded;
+                        if (loaded === list.length) {
+                            resolve(files);
+                        }
+                    });
+                }
+            }
+            return files;
+        });
+    }
+}
+exports.Zip = Zip;
+async function get(data) {
+    const z = (0, jszip_1.default)();
+    try {
+        if (data) {
+            await z.loadAsync(data);
+        }
+        return new Zip(z);
+    }
+    catch {
+        return null;
+    }
+}