gyomu 0.1.0

package/lib/archive/abstract.d.ts

@@ -0,0 +1,7 @@
+export declare abstract class AbstractBaseArchive {
+    readonly archiveFileName: string;
+    constructor(tarFilename: string);
+    protected __massageEntryPath(fileName: string): string;
+    protected __createDirectoryFromFileNameIfNotExist(destinationFilename: string): void;
+    protected __createDirectoryIfNotExist(destinationPath: string): void;
+}

package/lib/archive/abstract.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.AbstractBaseArchive = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+class AbstractBaseArchive {
+    constructor(tarFilename) {
+        this.archiveFileName = tarFilename;
+    }
+    __massageEntryPath(fileName) {
+        return fileName.replace(/\\/g, '/');
+    }
+    __createDirectoryFromFileNameIfNotExist(destinationFilename) {
+        let directoryName = path_1.default.dirname(destinationFilename);
+        if (destinationFilename.endsWith(path_1.default.sep))
+            directoryName = destinationFilename;
+        return this.__createDirectoryIfNotExist(directoryName);
+    }
+    __createDirectoryIfNotExist(destinationPath) {
+        let directoryName = destinationPath;
+        if (!fs_1.default.existsSync(directoryName)) {
+            //console.log(directoryName + ' to be created');
+            fs_1.default.mkdirSync(directoryName);
+        }
+    }
+}
+exports.AbstractBaseArchive = AbstractBaseArchive;

package/lib/archive/gz.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { ArchiveError } from '../errors';
+import { PromiseResult } from '../result';
+import { AbstractBaseArchive } from './abstract';
+import zlib from 'zlib';
+/**
+ * @remarks
+ * This class (extract side) doesn't support stream based retrieval yet
+ */
+export declare class GzipArchive extends AbstractBaseArchive {
+    static create(gzipFilename: string, sourceFilename: string): PromiseResult<boolean, ArchiveError>;
+    static extract(gzipFilename: string, destinationFilename: string): PromiseResult<boolean, ArchiveError>;
+    static getGzipTransform(): zlib.Gzip;
+    static getGunzipTransform(): zlib.Gunzip;
+    static extractStream(gzipFilename: string): zlib.Gunzip;
+}

package/lib/archive/gz.js

@@ -0,0 +1,66 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GzipArchive = void 0;
+const fs_1 = __importDefault(require("fs"));
+const errors_1 = require("../errors");
+const result_1 = require("../result");
+const abstract_1 = require("./abstract");
+const zlib_1 = __importDefault(require("zlib"));
+/**
+ * @remarks
+ * This class (extract side) doesn't support stream based retrieval yet
+ */
+class GzipArchive extends abstract_1.AbstractBaseArchive {
+    static create(gzipFilename, sourceFilename) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                fs_1.default.createReadStream(sourceFilename)
+                    .pipe(zlib_1.default.createGzip())
+                    .pipe(fs_1.default.createWriteStream(gzipFilename))
+                    .on('error', (err) => {
+                    resolve(new result_1.Failure(new errors_1.ArchiveError('Error on gzip compression', err)));
+                })
+                    .on('finish', () => {
+                    resolve((0, result_1.success)(true));
+                });
+            });
+        });
+    }
+    static extract(gzipFilename, destinationFilename) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                fs_1.default.createReadStream(gzipFilename)
+                    .pipe(zlib_1.default.createGunzip())
+                    .pipe(fs_1.default.createWriteStream(destinationFilename))
+                    .on('error', (err) => {
+                    resolve(new result_1.Failure(new errors_1.ArchiveError('Error on gzip uncompression', err)));
+                })
+                    .on('finish', () => {
+                    resolve((0, result_1.success)(true));
+                });
+            });
+        });
+    }
+    static getGzipTransform() {
+        return zlib_1.default.createGzip();
+    }
+    static getGunzipTransform() {
+        return zlib_1.default.createGunzip();
+    }
+    static extractStream(gzipFilename) {
+        return fs_1.default.createReadStream(gzipFilename).pipe(zlib_1.default.createGunzip());
+    }
+}
+exports.GzipArchive = GzipArchive;

package/lib/archive/index.d.ts

@@ -0,0 +1,3 @@
+export * from './gz';
+export * from './tar';
+export * from './zip';

package/lib/archive/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./gz"), exports);
+__exportStar(require("./tar"), exports);
+__exportStar(require("./zip"), exports);

package/lib/archive/tar.d.ts

@@ -0,0 +1,17 @@
+import { FileTransportInfo } from '../fileModel';
+import { ArchiveError } from '../errors';
+import { PromiseResult } from '../result';
+import { AbstractBaseArchive } from './abstract';
+/**
+ * @remarks
+ * This class (extract side) doesn't support stream based retrieval yet
+ */
+export declare class TarArchive extends AbstractBaseArchive {
+    static create(tarFileName: string, transferInformation: FileTransportInfo, needGZipCompression?: boolean): PromiseResult<boolean, ArchiveError>;
+    constructor(tarFilename: string);
+    fileExists(fileName: string): PromiseResult<boolean, ArchiveError>;
+    extractSingileFile(sourceEntryFullName: string, destinationFolderName: string): PromiseResult<boolean, ArchiveError>;
+    extractDirectory(sourceDirectory: string, destinationDirectory: string): PromiseResult<boolean, ArchiveError>;
+    extractAll(destinationDirectory: string): PromiseResult<boolean, ArchiveError>;
+    extract(transferInformation: FileTransportInfo): PromiseResult<boolean, ArchiveError>;
+}

package/lib/archive/tar.js

@@ -0,0 +1,165 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TarArchive = void 0;
+const path_1 = __importDefault(require("path"));
+const errors_1 = require("../errors");
+const result_1 = require("../result");
+// import tarStream from 'tar-stream';
+// import tar from 'tar-fs';
+const tar_1 = __importDefault(require("tar"));
+const abstract_1 = require("./abstract");
+/**
+ * @remarks
+ * This class (extract side) doesn't support stream based retrieval yet
+ */
+class TarArchive extends abstract_1.AbstractBaseArchive {
+    static create(tarFileName, transferInformation, needGZipCompression = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let currentDirectory = path_1.default.dirname(transferInformation.sourceFullNameWithBasePath);
+            let targetPathForTar = transferInformation.sourceFullNameWithBasePath.substring(currentDirectory.length + path_1.default.sep.length);
+            // console.log('current', currentDirectory);
+            // console.log('target', targetPathForTar);
+            if (!transferInformation.isSourceDirectory) {
+                return (0, result_1.fail)('Single File is not supported', errors_1.ArchiveError);
+            }
+            let tarOptions;
+            tarOptions = {
+                file: tarFileName,
+                cwd: transferInformation.sourceFullNameWithBasePath,
+            };
+            if (needGZipCompression) {
+                tarOptions = {
+                    file: tarFileName,
+                    cwd: transferInformation.sourceFullNameWithBasePath,
+                    gzip: true,
+                };
+            }
+            return new Promise((resolve, reject) => {
+                let result;
+                if (!needGZipCompression) {
+                    result = tar_1.default.create({
+                        file: tarFileName,
+                        cwd: transferInformation.sourceFullNameWithBasePath,
+                    }, ['']);
+                }
+                else {
+                    result = tar_1.default.create({
+                        file: tarFileName,
+                        cwd: transferInformation.sourceFullNameWithBasePath,
+                        gzip: true,
+                    }, ['']);
+                }
+                result
+                    .then(() => {
+                    return resolve((0, result_1.success)(true));
+                })
+                    .catch((err) => {
+                    return resolve((0, result_1.fail)('Fail to Tar archive', errors_1.ArchiveError));
+                });
+            });
+        });
+    }
+    constructor(tarFilename) {
+        super(tarFilename);
+    }
+    fileExists(fileName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            fileName = this.__massageEntryPath(fileName);
+            let isExist = false;
+            const extract = yield tar_1.default.list({
+                file: this.archiveFileName,
+                onentry: (entry) => {
+                    if (entry.header.path === fileName)
+                        isExist = true;
+                },
+            });
+            return (0, result_1.success)(isExist);
+        });
+    }
+    extractSingileFile(sourceEntryFullName, destinationFolderName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const targetEntryName = this.__massageEntryPath(sourceEntryFullName);
+            const numPathElementToSkip = (targetEntryName.match(/\//g) || []).length;
+            this.__createDirectoryIfNotExist(destinationFolderName);
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                yield tar_1.default
+                    .extract({
+                    cwd: destinationFolderName,
+                    file: this.archiveFileName,
+                    filter: (path, stat) => {
+                        return path === targetEntryName;
+                    },
+                    strip: numPathElementToSkip,
+                })
+                    .then(() => {
+                    return resolve((0, result_1.success)(true));
+                })
+                    .catch((reason) => {
+                    return resolve(new result_1.Failure(new errors_1.ArchiveError(`Fail to untar ${this.archiveFileName} -> ${targetEntryName}`, reason)));
+                });
+            }));
+        });
+    }
+    extractDirectory(sourceDirectory, destinationDirectory) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const targetEntryName = this.__massageEntryPath(sourceDirectory);
+            const numPathElementToSkip = !sourceDirectory
+                ? 0
+                : (targetEntryName.match(/\//g) || []).length + 1;
+            //let directoryName = path.dirname(destinationDirectory);
+            this.__createDirectoryIfNotExist(destinationDirectory);
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                yield tar_1.default
+                    .extract({
+                    cwd: destinationDirectory,
+                    file: this.archiveFileName,
+                    filter: (path, stat) => {
+                        return !targetEntryName || path.startsWith(targetEntryName);
+                    },
+                    strip: numPathElementToSkip,
+                })
+                    .then(() => {
+                    resolve((0, result_1.success)(true));
+                })
+                    .catch((reason) => {
+                    resolve(new result_1.Failure(new errors_1.ArchiveError(`Fail to untar ${this.archiveFileName} -> ${targetEntryName}`, reason)));
+                });
+            }));
+        });
+    }
+    extractAll(destinationDirectory) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.extractDirectory('', destinationDirectory);
+        });
+    }
+    extract(transferInformation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //console.log('directory', directory);
+            const targetEntryName = this.__massageEntryPath(transferInformation.sourceFullName);
+            if (transferInformation.sourceFileName !==
+                transferInformation.destinationFileName)
+                return (0, result_1.fail)('Destination filename must be same as original filename', errors_1.ArchiveError);
+            //console.log('targetEntryName:', targetEntryName, ':');
+            //const directory = await unzipper.Open.file(this.zipFilename);
+            if (!transferInformation.isSourceDirectory) {
+                return yield this.extractSingileFile(transferInformation.sourceFullName, transferInformation.destinationPath);
+            }
+            else {
+                return yield this.extractDirectory(transferInformation.sourceFullName, transferInformation.destinationFullName);
+            }
+        });
+    }
+}
+exports.TarArchive = TarArchive;

package/lib/archive/zip.d.ts

@@ -0,0 +1,28 @@
+import { FileTransportInfo } from '../fileModel';
+import { ArchiveError } from '../errors';
+import { PromiseResult } from '../result';
+import { AbstractBaseArchive } from './abstract';
+/**
+ * @remarks
+ * This class (extract side) doesn't support stream based retrieval yet
+ * This class  doesn't support AES decryption yet
+ */
+export declare class ZipArchive extends AbstractBaseArchive {
+    #private;
+    static _initialize(): void;
+    static create(zipFileName: string, transferInformationList: FileTransportInfo[], password?: string): PromiseResult<boolean, ArchiveError>;
+    readonly password: string;
+    readonly isAesEncrypted: boolean;
+    readonly encoding: string;
+    constructor({ zipFilename, password, encoding, isAesEncrypted, }: {
+        zipFilename: string;
+        password?: string;
+        encoding?: string;
+        isAesEncrypted?: boolean;
+    });
+    fileExists(fileName: string): PromiseResult<boolean, ArchiveError>;
+    extractSingileFile(sourceEntryFullName: string, destinationFullName: string): PromiseResult<boolean, ArchiveError>;
+    extractDirectory(sourceDirectory: string, destinationDirectory: string): PromiseResult<boolean, ArchiveError>;
+    extractAll(destinationDirectory: string): PromiseResult<boolean, ArchiveError>;
+    extract(transferInformation: FileTransportInfo): PromiseResult<boolean, ArchiveError>;
+}

package/lib/archive/zip.js

@@ -0,0 +1,254 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _ZipArchive_instances, _ZipArchive_unicode, _ZipArchive_massageFileEntryFullPath;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZipArchive = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const errors_1 = require("../errors");
+const result_1 = require("../result");
+const archiver_1 = __importDefault(require("archiver"));
+const unzipper_1 = __importDefault(require("unzipper"));
+const iconv_lite_1 = __importDefault(require("iconv-lite"));
+const abstract_1 = require("./abstract");
+const fileOperation_1 = require("../fileOperation");
+/**
+ * @remarks
+ * This class (extract side) doesn't support stream based retrieval yet
+ * This class  doesn't support AES decryption yet
+ */
+class ZipArchive extends abstract_1.AbstractBaseArchive {
+    constructor({ zipFilename, password = '', encoding = '', isAesEncrypted = false, }) {
+        super(zipFilename);
+        _ZipArchive_instances.add(this);
+        _ZipArchive_unicode.set(this, 0x800);
+        this.password = password;
+        this.isAesEncrypted = isAesEncrypted;
+        this.encoding = encoding;
+    }
+    static _initialize() {
+        archiver_1.default.registerFormat('zip-encrypted', require('archiver-zip-encrypted'));
+    }
+    static create(zipFileName, transferInformationList, password = '') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const archive = password === ''
+                ? archiver_1.default.create('zip', { forceZip64: true })
+                : archiver_1.default.create('zip-encrypted', {
+                    forceZip64: true,
+                    encryptionMethod: 'zip20',
+                    password,
+                });
+            //outputStream.on('close',()=>)
+            archive.on('warning', (err) => {
+                if (err.code === 'ENOENT') {
+                    console.log(err.message);
+                }
+                else {
+                    return new result_1.Failure(new errors_1.ArchiveError('Unknown Warning on Archive', err));
+                }
+            });
+            archive.on('error', (err) => {
+                return new result_1.Failure(new errors_1.ArchiveError('Unknown Error on Archive', err));
+            });
+            archive.on('close', () => {
+                //console.log('close');
+            });
+            archive.on('end', function () {
+                //console.log('Data has been drained');
+            });
+            archive.on('finish', function () {
+                //console.log('finish');
+            });
+            const outputStream = fs_1.default.createWriteStream(zipFileName);
+            archive.pipe(outputStream);
+            for (const transferInformation of transferInformationList) {
+                const sourcePath = transferInformation.sourceFullNameWithBasePath;
+                if (!fs_1.default.existsSync(sourcePath))
+                    return (0, result_1.fail)(`File Not Found: ${sourcePath}`, errors_1.ArchiveError);
+                if (!transferInformation.isSourceDirectory) {
+                    let destinationEntryName = transferInformation.destinationFullName.replace(path_1.default.sep, '/');
+                    archive.file(sourcePath, { name: destinationEntryName });
+                }
+                else {
+                    archive.directory(sourcePath, transferInformation.destinationPath
+                        ? transferInformation.destinationPath
+                        : false);
+                    //this.#buildZipArchiveInternal(sourcePath, sourcePath, archive);
+                }
+            }
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                yield archive
+                    .finalize()
+                    .then(() => __awaiter(this, void 0, void 0, function* () {
+                    if (!!password) {
+                        yield fileOperation_1.FileOperation.waitTillExclusiveAccess(zipFileName, 1);
+                    }
+                    return resolve((0, result_1.success)(true));
+                }))
+                    .catch((err) => {
+                    return resolve(new result_1.Failure(new errors_1.ArchiveError('Fail to zip archive', err)));
+                });
+                // console.log('final');
+                return resolve((0, result_1.success)(true));
+            }));
+        });
+    }
+    fileExists(fileName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            fileName = this.__massageEntryPath(fileName);
+            return new Promise((resolve, reject) => {
+                return unzipper_1.default.Open.file(this.archiveFileName)
+                    .then((directory) => {
+                    const targetFile = directory.files.find((f) => {
+                        return (f.type === 'File' &&
+                            __classPrivateFieldGet(this, _ZipArchive_instances, "m", _ZipArchive_massageFileEntryFullPath).call(this, f) === fileName);
+                    });
+                    return resolve((0, result_1.success)(!!targetFile));
+                })
+                    .catch((err) => {
+                    return resolve(new result_1.Failure(new errors_1.ArchiveError(`Fail to check file existence of ${this.archiveFileName}->${fileName}`, err)));
+                });
+            });
+        });
+    }
+    // #createDirectoryFromFileNameIfNotExist(destinationFilename: string) {
+    //   let directoryName = path.dirname(destinationFilename);
+    //   if (destinationFilename.endsWith(path.sep))
+    //     directoryName = destinationFilename;
+    //   return this.#createDirectoryIfNotExist(directoryName);
+    // }
+    // #createDirectoryIfNotExist(destinationPath: string) {
+    //   let directoryName = destinationPath;
+    //   if (!fs.existsSync(directoryName)) {
+    //     console.log(directoryName + ' to be created');
+    //     fs.mkdirSync(directoryName);
+    //   }
+    // }
+    extractSingileFile(sourceEntryFullName, destinationFullName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const targetEntryName = this.__massageEntryPath(sourceEntryFullName);
+            return unzipper_1.default.Open.file(this.archiveFileName).then((directory) => {
+                const targetFile = directory.files.find((f) => {
+                    return (f.type === 'File' &&
+                        __classPrivateFieldGet(this, _ZipArchive_instances, "m", _ZipArchive_massageFileEntryFullPath).call(this, f) === targetEntryName);
+                });
+                if (!targetFile) {
+                    console.log(`File not found :${targetEntryName}`);
+                    return (0, result_1.fail)(`File not found :${targetEntryName}`, errors_1.ArchiveError);
+                }
+                this.__createDirectoryFromFileNameIfNotExist(destinationFullName);
+                return new Promise((resolve, reject) => {
+                    targetFile
+                        .stream(this.password)
+                        .pipe(fs_1.default.createWriteStream(destinationFullName))
+                        .on('error', (err) => {
+                        return resolve(new result_1.Failure(new errors_1.ArchiveError(`Unknown Error on extract ${__classPrivateFieldGet(this, _ZipArchive_instances, "m", _ZipArchive_massageFileEntryFullPath).call(this, targetFile)}`, err)));
+                    })
+                        .on('finish', () => {
+                        resolve((0, result_1.success)(true));
+                    });
+                });
+            });
+        });
+    }
+    extractDirectory(sourceDirectory, destinationDirectory) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const targetEntryName = this.__massageEntryPath(sourceDirectory);
+            const result = unzipper_1.default.Open.file(this.archiveFileName).then((directory) => __awaiter(this, void 0, void 0, function* () {
+                const targetFileList = directory.files.filter((f) => __classPrivateFieldGet(this, _ZipArchive_instances, "m", _ZipArchive_massageFileEntryFullPath).call(this, f).startsWith(targetEntryName));
+                if (!targetFileList || targetFileList.length === 0) {
+                    return (0, result_1.fail)(`Folder not found : ${targetEntryName}`, errors_1.ArchiveError);
+                }
+                this.__createDirectoryIfNotExist(destinationDirectory);
+                targetFileList
+                    .filter((file) => file.type === 'Directory')
+                    .forEach((file) => {
+                    const entryFullPath = __classPrivateFieldGet(this, _ZipArchive_instances, "m", _ZipArchive_massageFileEntryFullPath).call(this, file);
+                    let destinationPath = path_1.default.join(destinationDirectory, entryFullPath
+                        .substring(targetEntryName.length)
+                        .replace('/', path_1.default.sep));
+                    this.__createDirectoryFromFileNameIfNotExist(destinationPath);
+                });
+                const resultPromiseList = yield targetFileList
+                    .filter((file) => file.type === 'File')
+                    .map((file) => __awaiter(this, void 0, void 0, function* () {
+                    const entryFullPath = __classPrivateFieldGet(this, _ZipArchive_instances, "m", _ZipArchive_massageFileEntryFullPath).call(this, file);
+                    let destinationPath = path_1.default.join(destinationDirectory, entryFullPath
+                        .substring(targetEntryName.length)
+                        .replace('/', path_1.default.sep));
+                    this.__createDirectoryFromFileNameIfNotExist(destinationPath);
+                    return new Promise((resolve, reject) => {
+                        file
+                            .stream(this.password)
+                            .pipe(fs_1.default.createWriteStream(destinationPath))
+                            .on('error', (err) => {
+                            reject({
+                                err: err,
+                                fileName: __classPrivateFieldGet(this, _ZipArchive_instances, "m", _ZipArchive_massageFileEntryFullPath).call(this, file),
+                            });
+                        })
+                            .on('finish', resolve);
+                    });
+                }));
+                const result = yield Promise.all(resultPromiseList)
+                    .then((results) => {
+                    //return new Promise<void>((resolve,reject)=>{resolve();})
+                    return (0, result_1.success)(true);
+                })
+                    .catch((reason) => {
+                    return new result_1.Failure(new errors_1.ArchiveError(`Error on unarchive ${reason.fileName}`, reason.err));
+                });
+                return result;
+            }));
+            return result;
+        });
+    }
+    extractAll(destinationDirectory) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.extractDirectory('', destinationDirectory);
+        });
+    }
+    extract(
+    //zipFilename: string,
+    transferInformation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //console.log('directory', directory);
+            const targetEntryName = this.__massageEntryPath(transferInformation.sourceFullName);
+            //console.log('targetEntryName:', targetEntryName, ':');
+            //const directory = await unzipper.Open.file(this.zipFilename);
+            if (!transferInformation.isSourceDirectory) {
+                return yield this.extractSingileFile(transferInformation.sourceFullName, transferInformation.destinationFullName);
+            }
+            else {
+                return yield this.extractDirectory(transferInformation.sourceFullName, transferInformation.destinationFullName);
+            }
+        });
+    }
+}
+exports.ZipArchive = ZipArchive;
+_ZipArchive_unicode = new WeakMap(), _ZipArchive_instances = new WeakSet(), _ZipArchive_massageFileEntryFullPath = function _ZipArchive_massageFileEntryFullPath(file) {
+    if (!this.encoding ||
+        (!!file.flags && (file.flags & __classPrivateFieldGet(this, _ZipArchive_unicode, "f")) !== 0)) {
+        return file.path;
+    }
+    const decoded = iconv_lite_1.default.decode(file.pathBuffer, this.encoding);
+    // console.log(decoded);
+    return decoded;
+};
+ZipArchive._initialize();

package/lib/base64.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+export declare type SupportEncoding = 'shiftjis' | 'utf8';
+export declare const string2Base64String: (plainString: string) => string;
+export declare const buffer2Base64String: (buffer: Buffer) => string;
+export declare const base64String2String: (encodedString: string) => string;
+export declare const base64String2Buffer: (encodedString: string) => Buffer;

package/lib/base64.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64String2Buffer = exports.base64String2String = exports.buffer2Base64String = exports.string2Base64String = void 0;
+const string2Base64String = (plainString) => {
+    return (0, exports.buffer2Base64String)(Buffer.from(plainString));
+};
+exports.string2Base64String = string2Base64String;
+const buffer2Base64String = (buffer) => {
+    return buffer.toString('base64');
+};
+exports.buffer2Base64String = buffer2Base64String;
+const base64String2String = (encodedString) => {
+    return (0, exports.base64String2Buffer)(encodedString).toString();
+};
+exports.base64String2String = base64String2String;
+const base64String2Buffer = (encodedString) => {
+    return Buffer.from(encodedString, 'base64');
+};
+exports.base64String2Buffer = base64String2Buffer;
+// export const base64String2ArrayBuffer = (
+//   encodedString: string
+// ): ArrayBuffer => {
+//   return base64String2Buffer(encodedString).buffer;
+// };

package/lib/buffer.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+export declare const stringToArrayBuffer: (source: string) => ArrayBuffer;
+export declare const arrayBufferToString: (source: ArrayBuffer) => string;
+export declare const bufferToArrayBuffer: (buffer: Buffer) => ArrayBuffer;