clickgo 3.16.28 → 4.0.1

package/dist/lib/zip.d.ts

@@ -1,40 +0,0 @@
-import jszip from 'jszip';
-import * as types from '../../types';
-export declare class Zip {
-    private readonly _zip;
-    private _path;
-    constructor(zip: jszip);
-    getContent(path: string): Promise<string | null>;
-    getContent<T extends types.TZipOutputType>(path: string, type: T): Promise<types.IZipOutputByType[T] | null>;
-    putContent<T extends types.TZipInputType>(path: string, data: types.IZipInputByType[T], options?: {
-        'base64'?: boolean;
-        'binary'?: boolean;
-        'date'?: Date;
-    }): void;
-    unlink(path: string): void;
-    stats(path: string): types.IZipStats | null;
-    isDir(path: string): types.IZipStats | false;
-    isFile(path: string): types.IZipStats | false;
-    readDir(path?: string, opt?: {
-        'hasChildren'?: boolean;
-        'hasDir'?: boolean;
-        'pathAsKey'?: false;
-    }): types.IZipItem[];
-    readDir(path?: string, opt?: {
-        'hasChildren'?: boolean;
-        'hasDir'?: boolean;
-        'pathAsKey': true;
-    }): Record<string, types.IZipItem>;
-    private _readDir;
-    private _list;
-    private _refreshList;
-    pwd(): string;
-    cd(dir: string): string;
-    generate<T extends types.TZipOutputType>(options?: {
-        'type'?: T;
-        'level'?: number;
-        'onUpdate'?: (percent: number, currentFile: string | null) => void;
-    }): Promise<types.IZipOutputByType[T]>;
-    getList(): Promise<Record<string, Blob | string>>;
-}
-export declare function get(data?: types.TZipInputFileFormat): Promise<Zip | null>;

package/dist/lib/zip.js

@@ -1,382 +0,0 @@
-"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 tool = __importStar(require("./tool"));
-class Zip {
-    constructor(zip) {
-        this._path = '/';
-        this._list = {};
-        this._zip = zip;
-        this._refreshList();
-    }
-    async getContent(path, type = 'string') {
-        path = tool.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 = tool.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 = tool.urlResolve(this._path, path);
-        this._zip.remove(path.slice(1));
-        this._refreshList();
-    }
-    stats(path) {
-        path = tool.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 = tool.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 = tool.urlResolve(this._path, dir);
-        if (!this._path.endsWith('/')) {
-            this._path += '/';
-        }
-        return this._path;
-    }
-    generate(options = {}) {
-        const opt = {};
-        if (options.type === undefined) {
-            opt.type = 'blob';
-        }
-        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 mime = tool.getMimeByPath(file.name);
-                if (['txt', 'json', 'js', 'css', 'xml', 'html'].includes(mime.ext)) {
-                    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, 'arraybuffer').then(function (fb) {
-                        if (fb) {
-                            files[file.path + file.name] = new Blob([fb], {
-                                'type': mime.mime
-                            });
-                        }
-                        ++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;
-    }
-}