gyomu 0.1.0

package/lib/fileModel.d.ts

@@ -0,0 +1,96 @@
+export declare class FileInfo {
+    readonly fileName: string;
+    readonly fullPath: string;
+    readonly directoryName: string;
+    readonly directoryPath: string;
+    readonly size: number;
+    readonly extension: string;
+    readonly createTime: Date;
+    readonly updateTime: Date;
+    readonly lastAccessTime: Date;
+    readonly isFile: boolean;
+    constructor(filePath: string);
+}
+export declare const FilterType: {
+    readonly FileName: "Name";
+    readonly CreateTime: "Create Time";
+    readonly LastAccessTime: "Last Access Time";
+    readonly LastModifiedTime: "Last Modified Time";
+};
+export declare type FilterType = typeof FilterType[keyof typeof FilterType];
+export declare const FileCompareType: {
+    readonly Equal: "Equal";
+    readonly Larger: "Larger";
+    readonly Less: "Less";
+    readonly LargerOrEqual: "LargerOrEqual";
+    readonly LessOrEqual: "LessOrEqual";
+};
+export declare type FileCompareType = typeof FileCompareType[keyof typeof FileCompareType];
+export declare const FileArchiveType: {
+    readonly Zip: "zip";
+    readonly Tgz: "tgz";
+    readonly BZip2: "bz2";
+    readonly GZip: "gz";
+    readonly Tar: "tar";
+    readonly GuessFromFileName: "unknown";
+};
+export declare type FileArchiveType = typeof FileArchiveType[keyof typeof FileArchiveType];
+export declare class FileFilterInfo {
+    readonly kind: FilterType;
+    readonly operator: FileCompareType;
+    readonly nameFilter: string;
+    readonly targetDate: Date;
+    constructor(kind: FilterType, operator: FileCompareType, filter: string | Date);
+}
+export declare class FileTransportInfo {
+    #private;
+    readonly sourceFileName: string;
+    readonly sourceFolderName: string;
+    readonly basePath: string;
+    readonly deleteSourceFileAfterCompletion: boolean;
+    readonly overwriteDestination: boolean;
+    readonly isSourceDirectory: boolean;
+    readonly isDestinationDirectory: boolean;
+    readonly isDestinationRoot: boolean;
+    readonly filterConditions?: FileFilterInfo[];
+    /**
+     * Base	Sdir	Sname	Ddir	Dname		(S)full+base	    (S)Full	    (S)path (S)name (D)full	    (D)path (D)name
+     * x   	x	    x	    x	    x		    base\SDir\Sname	    SDir\Sname	SDir    Sname   Ddir\Dname	Ddir    Dname
+     * x   	x   	x	    x	    	    	base\SDir\Sname	    SDir\Sname	SDir    Sname   Ddir\Sname	Ddir    Sname
+     * x   	x	    x   	    	x	    	base\SDir\Sname	    SDir\Sname	SDir    Sname   SDir\Dname	Sdir    Dname
+     * x   	x	    x	    	    	    	base\SDir\Sname	    SDir\Sname	SDir    Sname   SDir\Sname	SDir    Sname
+     * x   	x   	    	x   	    		base\SDir	          SDir	    SDir		    Ddir	    Ddir
+     * x   	x	                				base\SDir	          SDir	    SDir		    SDir	    SDir
+     * x                   						base
+     * x	            	x	        		base				                            Ddir	    Ddir
+     * x   	    	x   	x   	x	    	base\Sname	        Sname		        Sname	Ddir\Dname	Ddir	Dname
+     * x   	    	x	    x	        		base\Sname	        Sname		        Sname	Ddir\Sname	Ddir	Sname
+     * x       		x	        	x	    	base\Sname	        Sname		        Sname	Dname		Dname
+     * x	        x	            			base\Sname	        Sname		        Sname	Sname		Sname
+     *     	x   	x   	x	    x	                            SDir\Sname	SDir	Sname	Ddir\Dname	Ddir	Dname
+     * 	    x	    x	    x				                        SDir\Sname	SDir	Sname	Ddir\Sname	Ddir	Sname
+     * 	    x	    x		        x			                    SDir\Sname	SDir	Sname	SDir\Dname	SDir	Dname
+     * 	    x	    x					                            SDir\Sname	SDir	Sname	SDir\Sname	SDir	Sname
+     * 	    x	        	x				                        SDir	    SDir	    	Ddir	    Ddir
+     * 	    x						                                SDir	    SDir		    SDir	    SDir
+     * 		        x	    x	    x			                    Sname		        Sname	Ddir\Dname	Ddir	Dname
+     * 		        x	    x				                        Sname		        Sname	Ddir\Sname	Ddir	Sname
+     * 		        x		        x			                    Sname		        Sname	Dname		        Dname
+     * 		        x					                            Sname		        Sname	Sname		        Sname
+     */
+    constructor({ basePath, sourceFilename, sourceFolderName, destinationFileName, destinationFolderName, deleteSourceFileAfterCompletion, overwriteDestination, filterConditions, }: {
+        basePath?: string;
+        sourceFilename?: string;
+        sourceFolderName?: string;
+        destinationFileName?: string;
+        destinationFolderName?: string;
+        deleteSourceFileAfterCompletion?: boolean;
+        overwriteDestination?: boolean;
+        filterConditions?: FileFilterInfo[];
+    });
+    get sourceFullName(): string;
+    get sourceFullNameWithBasePath(): string;
+    get destinationFileName(): string;
+    get destinationPath(): string;
+    get destinationFullName(): string;
+}

package/lib/fileModel.js

@@ -0,0 +1,170 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+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 _FileTransportInfo_destinationFileName, _FileTransportInfo_destinationFolderName;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileTransportInfo = exports.FileFilterInfo = exports.FileArchiveType = exports.FileCompareType = exports.FilterType = exports.FileInfo = void 0;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const date_fns_1 = require("date-fns");
+const errors_1 = require("./errors");
+class FileInfo {
+    constructor(filePath) {
+        //console.log('FileInfo', filePath);
+        const stats = (0, fs_1.statSync)(filePath);
+        this.isFile = stats.isFile();
+        if (this.isFile) {
+            this.fileName = path_1.default.basename(filePath);
+            this.fullPath = path_1.default.resolve(filePath);
+            this.directoryName = path_1.default.basename(path_1.default.dirname(filePath));
+            this.directoryPath = path_1.default.dirname(path_1.default.resolve(filePath));
+            this.extension = path_1.default.extname(filePath);
+        }
+        else {
+            this.fileName = '';
+            this.extension = '';
+            this.fullPath = path_1.default.resolve(filePath);
+            this.directoryName = path_1.default.basename(path_1.default.dirname(filePath));
+            this.directoryPath = path_1.default.dirname(path_1.default.resolve(filePath));
+        }
+        this.size = stats.size;
+        this.createTime = stats.birthtime;
+        this.updateTime = stats.mtime;
+        this.lastAccessTime = stats.atime;
+    }
+}
+exports.FileInfo = FileInfo;
+exports.FilterType = {
+    FileName: 'Name',
+    CreateTime: 'Create Time',
+    LastAccessTime: 'Last Access Time',
+    LastModifiedTime: 'Last Modified Time',
+};
+exports.FileCompareType = {
+    Equal: 'Equal',
+    Larger: 'Larger',
+    Less: 'Less',
+    LargerOrEqual: 'LargerOrEqual',
+    LessOrEqual: 'LessOrEqual',
+};
+exports.FileArchiveType = {
+    Zip: 'zip',
+    Tgz: 'tgz',
+    BZip2: 'bz2',
+    GZip: 'gz',
+    Tar: 'tar',
+    GuessFromFileName: 'unknown',
+};
+class FileFilterInfo {
+    constructor(kind, operator, filter) {
+        this.kind = kind;
+        this.operator = operator;
+        if (this.kind === exports.FilterType.FileName && typeof filter === 'string') {
+            this.nameFilter = filter;
+            this.targetDate = new Date();
+        }
+        else if (this.kind !== exports.FilterType.FileName) {
+            this.nameFilter = '';
+            if (typeof filter === 'string')
+                this.targetDate = (0, date_fns_1.parse)(filter, 'yyyyMMdd', 0);
+            else
+                this.targetDate = filter;
+        }
+        else {
+            throw new errors_1.ValueError('Date Parameter is invalid:' + filter);
+        }
+    }
+}
+exports.FileFilterInfo = FileFilterInfo;
+class FileTransportInfo {
+    /**
+     * Base	Sdir	Sname	Ddir	Dname		(S)full+base	    (S)Full	    (S)path (S)name (D)full	    (D)path (D)name
+     * x   	x	    x	    x	    x		    base\SDir\Sname	    SDir\Sname	SDir    Sname   Ddir\Dname	Ddir    Dname
+     * x   	x   	x	    x	    	    	base\SDir\Sname	    SDir\Sname	SDir    Sname   Ddir\Sname	Ddir    Sname
+     * x   	x	    x   	    	x	    	base\SDir\Sname	    SDir\Sname	SDir    Sname   SDir\Dname	Sdir    Dname
+     * x   	x	    x	    	    	    	base\SDir\Sname	    SDir\Sname	SDir    Sname   SDir\Sname	SDir    Sname
+     * x   	x   	    	x   	    		base\SDir	          SDir	    SDir		    Ddir	    Ddir
+     * x   	x	                				base\SDir	          SDir	    SDir		    SDir	    SDir
+     * x                   						base
+     * x	            	x	        		base				                            Ddir	    Ddir
+     * x   	    	x   	x   	x	    	base\Sname	        Sname		        Sname	Ddir\Dname	Ddir	Dname
+     * x   	    	x	    x	        		base\Sname	        Sname		        Sname	Ddir\Sname	Ddir	Sname
+     * x       		x	        	x	    	base\Sname	        Sname		        Sname	Dname		Dname
+     * x	        x	            			base\Sname	        Sname		        Sname	Sname		Sname
+     *     	x   	x   	x	    x	                            SDir\Sname	SDir	Sname	Ddir\Dname	Ddir	Dname
+     * 	    x	    x	    x				                        SDir\Sname	SDir	Sname	Ddir\Sname	Ddir	Sname
+     * 	    x	    x		        x			                    SDir\Sname	SDir	Sname	SDir\Dname	SDir	Dname
+     * 	    x	    x					                            SDir\Sname	SDir	Sname	SDir\Sname	SDir	Sname
+     * 	    x	        	x				                        SDir	    SDir	    	Ddir	    Ddir
+     * 	    x						                                SDir	    SDir		    SDir	    SDir
+     * 		        x	    x	    x			                    Sname		        Sname	Ddir\Dname	Ddir	Dname
+     * 		        x	    x				                        Sname		        Sname	Ddir\Sname	Ddir	Sname
+     * 		        x		        x			                    Sname		        Sname	Dname		        Dname
+     * 		        x					                            Sname		        Sname	Sname		        Sname
+     */
+    constructor({ basePath = '', sourceFilename = '', sourceFolderName = '', destinationFileName = '', destinationFolderName = '', deleteSourceFileAfterCompletion = false, overwriteDestination = false, filterConditions = undefined, }) {
+        _FileTransportInfo_destinationFileName.set(this, void 0);
+        _FileTransportInfo_destinationFolderName.set(this, void 0);
+        this.basePath = basePath;
+        this.sourceFileName = sourceFilename;
+        this.sourceFolderName = sourceFolderName;
+        __classPrivateFieldSet(this, _FileTransportInfo_destinationFileName, destinationFileName, "f");
+        __classPrivateFieldSet(this, _FileTransportInfo_destinationFolderName, destinationFolderName, "f");
+        this.deleteSourceFileAfterCompletion = deleteSourceFileAfterCompletion;
+        this.overwriteDestination = overwriteDestination;
+        this.filterConditions = filterConditions;
+        this.isSourceDirectory = !this.sourceFileName;
+        this.isDestinationDirectory = !this.destinationFileName;
+        this.isDestinationRoot =
+            !this.sourceFolderName && !__classPrivateFieldGet(this, _FileTransportInfo_destinationFolderName, "f");
+        if (!this.sourceFileName && __classPrivateFieldGet(this, _FileTransportInfo_destinationFileName, "f"))
+            throw new errors_1.ValueError('Invalid Parameter');
+        if (!this.basePath && !this.sourceFolderName && !this.sourceFileName)
+            throw new errors_1.ValueError('Invalid Parameter');
+    }
+    get sourceFullName() {
+        if (!this.sourceFolderName)
+            return this.sourceFileName;
+        if (!this.sourceFileName)
+            return this.sourceFolderName;
+        return path_1.default.join(this.sourceFolderName, this.sourceFileName);
+    }
+    get sourceFullNameWithBasePath() {
+        if (!this.sourceFullName)
+            return this.basePath;
+        if (!!this.basePath)
+            return path_1.default.join(this.basePath, this.sourceFullName);
+        return this.sourceFullName;
+    }
+    get destinationFileName() {
+        if (!__classPrivateFieldGet(this, _FileTransportInfo_destinationFileName, "f"))
+            return this.sourceFileName;
+        return __classPrivateFieldGet(this, _FileTransportInfo_destinationFileName, "f");
+    }
+    get destinationPath() {
+        if (!__classPrivateFieldGet(this, _FileTransportInfo_destinationFolderName, "f"))
+            return this.sourceFolderName;
+        return __classPrivateFieldGet(this, _FileTransportInfo_destinationFolderName, "f");
+    }
+    get destinationFullName() {
+        if (!this.destinationPath)
+            return this.destinationFileName;
+        if (!this.destinationFileName)
+            return this.destinationPath;
+        return path_1.default.join(this.destinationPath, this.destinationFileName);
+    }
+}
+exports.FileTransportInfo = FileTransportInfo;
+_FileTransportInfo_destinationFileName = new WeakMap(), _FileTransportInfo_destinationFolderName = new WeakMap();

package/lib/fileOperation.d.ts

@@ -0,0 +1,11 @@
+import { Configurator } from './configurator';
+import { FileArchiveType, FileFilterInfo, FileInfo, FileTransportInfo } from './fileModel';
+import { PromiseResult, Result } from './result';
+import { AccessError, ArchiveError, TimeoutError } from './errors';
+export declare class FileOperation {
+    #private;
+    static canAccess(fileName: string, readOnly?: boolean): PromiseResult<boolean, AccessError>;
+    static waitTillExclusiveAccess(fileName: string, timeoutSeconds: number): PromiseResult<boolean, TimeoutError>;
+    static search(parentDirectory: string, filterConditions: FileFilterInfo[], isRecursive?: boolean): FileInfo[];
+    static archive(archiveFileName: string, archiveType: FileArchiveType, sourceFileList: FileTransportInfo[], config: Configurator, applicationId: number, password?: string): Promise<Result<boolean, ArchiveError>>;
+}

package/lib/fileOperation.js

@@ -0,0 +1,275 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 _a, _FileOperation_isFileValid, _FileOperation_isFileValidForFileter, _FileOperation_isFileNameMatch, _FileOperation_isFileDateMatch;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileOperation = void 0;
+const fs = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
+const fileModel_1 = require("./fileModel");
+const compareAsc_1 = __importDefault(require("date-fns/compareAsc"));
+const result_1 = require("./result");
+const errors_1 = require("./errors");
+const zip_1 = require("./archive/zip");
+const tar_1 = require("./archive/tar");
+const date_fns_1 = require("date-fns");
+const gz_1 = require("./archive/gz");
+const timer_1 = require("./timer");
+class FileOperation {
+    static canAccess(fileName, readOnly = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                if (!fs.existsSync(fileName))
+                    return resolve((0, result_1.fail)(`File Not exist: ${fileName}`, errors_1.AccessError));
+                const specialExtension = ['xls', 'xlsm', 'xlsx', 'zip'];
+                const stat = fs.statSync(fileName);
+                if (specialExtension.includes(path_1.default.extname(fileName)) && stat.size === 0)
+                    return resolve((0, result_1.fail)(`File is invalid: ${fileName}`, errors_1.AccessError));
+                if (readOnly)
+                    return resolve((0, result_1.success)(true));
+                yield setTimeout(() => {
+                    const stat2 = fs.statSync(fileName);
+                    if (!(0, date_fns_1.isEqual)(stat.ctime, stat2.ctime) ||
+                        !(0, date_fns_1.isEqual)(stat.mtime, stat2.mtime)) {
+                        // console.log(stat.ctime, stat2.ctime);
+                        // console.log(stat.mtime, stat2.mtime);
+                        return resolve((0, result_1.fail)(`File is under operation: ${fileName}`, errors_1.AccessError));
+                    }
+                    //console.log('Accessible', stat2.mtime);
+                    return resolve((0, result_1.success)(true));
+                }, 100);
+                return false;
+            }));
+            // try {
+            //   const fileHandle = fs.openSync(
+            //     fileName,
+            //     readOnly ? 'r' : 'r+',
+            //     readOnly
+            //       ? fs.constants.O_RDONLY
+            //       : fs.constants.O_RDWR | fs.constants.O_EXCL
+            //   );
+            //   fs.closeSync(fileHandle);
+            //   return true;
+            // } catch (err) {
+            //   return false;
+            // }
+        });
+    }
+    static waitTillExclusiveAccess(fileName, timeoutSeconds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, timer_1.polling)(`File Access check ${fileName}`, timeoutSeconds, 0.5, (fileName) => __awaiter(this, void 0, void 0, function* () {
+                const accessible = yield this.canAccess(fileName, false);
+                if (accessible.isSuccess()) {
+                    //console.log('accessible', accessible.value);
+                    return (0, result_1.success)(accessible.value);
+                }
+                else
+                    return (0, result_1.success)(false);
+            }), fileName);
+            // const timeoutTime = new Date().getTime() + timeoutSeconds * 1000;
+            // const nextIntervalMilliSecond = 500;
+            // const accessible = await this.canAccess(fileName, false);
+            // if (accessible.isSuccess() && accessible.value) {
+            //   return success(accessible.value);
+            // }
+            // if (new Date().getTime() > timeoutTime) {
+            //   return fail(`Timeout happen to access ${fileName}`, TimeoutError);
+            // }
+            // return new Promise(async (resolve, reject) => {
+            //   const timerId = await setInterval(async () => {
+            //     const accessible = await this.canAccess(fileName, false);
+            //     if (accessible.isSuccess() && accessible.value) {
+            //       clearInterval(timerId);
+            //       return resolve(success(accessible.value));
+            //     }
+            //     if (new Date().getTime() > timeoutTime) {
+            //       //console.log('Timeout');
+            //       clearInterval(timerId);
+            //       return resolve(
+            //         fail(`Timeout happen to access ${fileName}`, TimeoutError)
+            //       );
+            //     }
+            //     //console.log('wait next', new Date().getTime(), timeoutTime);
+            //   }, nextIntervalMilliSecond);
+            // });
+        });
+    }
+    static search(parentDirectory, filterConditions, isRecursive = false) {
+        const fileInfoList = new Array();
+        if (!fs.existsSync(parentDirectory))
+            return fileInfoList;
+        fs.readdirSync(parentDirectory, { withFileTypes: true }).forEach((dirent) => {
+            if (dirent.isFile()) {
+                const fullPath = path_1.default.join(path_1.default.resolve(parentDirectory), dirent.name);
+                const [result, fileInfo] = __classPrivateFieldGet(this, _a, "m", _FileOperation_isFileValid).call(this, fullPath, filterConditions);
+                if (result) {
+                    fileInfoList.push(fileInfo);
+                }
+            }
+            else if (dirent.isDirectory()) {
+                const fullPath = path_1.default.join(path_1.default.resolve(parentDirectory), dirent.name);
+                const childInfoList = FileOperation.search(fullPath, filterConditions, isRecursive);
+                fileInfoList.push(...childInfoList);
+            }
+            // const fullPath = path.join(path.resolve(parentDirectory), file);
+            // console.log(fullPath);
+            // const [result, fileInfo] = this.#isFileValid(fullPath, filterConditions);
+            // if (result) fileInfoList.push(fileInfo);
+            // if (!fileInfo.isFile && isRecursive) {
+            //   const childInfoList = FileOperation.search(
+            //     fileInfo.directoryPath,
+            //     filterConditions,
+            //     isRecursive
+            //   );
+            //   fileInfoList.push(...childInfoList);
+            // }
+        });
+        return fileInfoList;
+    }
+    static archive(archiveFileName, archiveType, sourceFileList, config, applicationId, password = '') {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!sourceFileList || sourceFileList.length === 0)
+                return (0, result_1.fail)('Source File Not Specified to archive', errors_1.ArchiveError);
+            const archiveInformation = new fileModel_1.FileInfo(archiveFileName);
+            if (archiveType == fileModel_1.FileArchiveType.GuessFromFileName) {
+                const extension = archiveInformation.extension.toLowerCase();
+                switch (extension) {
+                    case 'zip':
+                        archiveType = fileModel_1.FileArchiveType.Zip;
+                        break;
+                    case 'tgz':
+                        archiveType = fileModel_1.FileArchiveType.Tgz;
+                        break;
+                    case 'bz2':
+                        archiveType = fileModel_1.FileArchiveType.BZip2;
+                        break;
+                    case 'gz':
+                        archiveType = fileModel_1.FileArchiveType.GZip;
+                        break;
+                    case 'tar':
+                        archiveType = fileModel_1.FileArchiveType.Tar;
+                        break;
+                    default:
+                        return (0, result_1.fail)('File Extension Not supported for archiving ' + extension, errors_1.ArchiveError);
+                }
+            }
+            if (archiveType == fileModel_1.FileArchiveType.BZip2 ||
+                archiveType == fileModel_1.FileArchiveType.GZip) {
+                if (sourceFileList.length > 1 || sourceFileList[0].isSourceDirectory)
+                    return (0, result_1.fail)('Multiple files are not supported in this compression type: ' +
+                        archiveType, errors_1.ArchiveError);
+            }
+            if (archiveType !== fileModel_1.FileArchiveType.Zip && password !== '')
+                return (0, result_1.fail)('password is not supported on other than zip format', errors_1.ArchiveError);
+            if (archiveType === fileModel_1.FileArchiveType.Tar ||
+                archiveType === fileModel_1.FileArchiveType.Tgz) {
+                if (sourceFileList.length > 1 || !sourceFileList[0].isSourceDirectory)
+                    return (0, result_1.fail)('single file or multiple directory is not supported in this compression type: ' +
+                        archiveType, errors_1.ArchiveError);
+            }
+            switch (archiveType) {
+                case fileModel_1.FileArchiveType.Zip:
+                    return yield zip_1.ZipArchive.create(archiveInformation.fullPath, sourceFileList, password);
+                case fileModel_1.FileArchiveType.Tar:
+                    return yield tar_1.TarArchive.create(archiveInformation.fullPath, sourceFileList[0]);
+                case fileModel_1.FileArchiveType.GZip:
+                    return yield gz_1.GzipArchive.create(archiveInformation.fullPath, sourceFileList[0].sourceFullName);
+                case fileModel_1.FileArchiveType.Tgz:
+                    return yield tar_1.TarArchive.create(archiveInformation.fullPath, sourceFileList[0], true);
+            }
+            return (0, result_1.success)(true);
+        });
+    }
+}
+exports.FileOperation = FileOperation;
+_a = FileOperation, _FileOperation_isFileValid = function _FileOperation_isFileValid(fileFullPath, filterConditions) {
+    let isMatch = true;
+    const fileInformation = new fileModel_1.FileInfo(fileFullPath);
+    if (!fileInformation.isFile)
+        return [false, fileInformation];
+    if (!filterConditions || filterConditions.length === 0)
+        return [true, fileInformation];
+    for (var filterInfo of filterConditions) {
+        isMatch = __classPrivateFieldGet(this, _a, "m", _FileOperation_isFileValidForFileter).call(this, fileInformation, filterInfo);
+        if (!isMatch)
+            break;
+    }
+    return [isMatch, fileInformation];
+}, _FileOperation_isFileValidForFileter = function _FileOperation_isFileValidForFileter(fileInformation, filterInformation) {
+    switch (filterInformation.kind) {
+        case fileModel_1.FilterType.FileName:
+            return __classPrivateFieldGet(this, _a, "m", _FileOperation_isFileNameMatch).call(this, fileInformation.fileName, filterInformation.nameFilter, filterInformation.operator);
+        case fileModel_1.FilterType.CreateTime:
+            return __classPrivateFieldGet(this, _a, "m", _FileOperation_isFileDateMatch).call(this, fileInformation.createTime, filterInformation.targetDate, filterInformation.operator);
+        case fileModel_1.FilterType.LastAccessTime:
+            return __classPrivateFieldGet(this, _a, "m", _FileOperation_isFileDateMatch).call(this, fileInformation.lastAccessTime, filterInformation.targetDate, filterInformation.operator);
+        case fileModel_1.FilterType.LastModifiedTime:
+            return __classPrivateFieldGet(this, _a, "m", _FileOperation_isFileDateMatch).call(this, fileInformation.updateTime, filterInformation.targetDate, filterInformation.operator);
+    }
+}, _FileOperation_isFileNameMatch = function _FileOperation_isFileNameMatch(fileName, targetFilter, compareType) {
+    switch (compareType) {
+        case fileModel_1.FileCompareType.Equal:
+            const match = fileName.match(targetFilter);
+            return !!match && match.length > 0;
+        case fileModel_1.FileCompareType.Larger:
+            return fileName > targetFilter;
+        case fileModel_1.FileCompareType.LargerOrEqual:
+            return fileName >= targetFilter;
+        case fileModel_1.FileCompareType.Less:
+            return fileName < targetFilter;
+        case fileModel_1.FileCompareType.LessOrEqual:
+            return fileName <= targetFilter;
+    }
+}, _FileOperation_isFileDateMatch = function _FileOperation_isFileDateMatch(fileDate, targetFilter, compareType) {
+    const result = (0, compareAsc_1.default)(fileDate, targetFilter);
+    switch (compareType) {
+        case fileModel_1.FileCompareType.Equal:
+            return result === 0;
+        case fileModel_1.FileCompareType.Larger:
+            return result > 0;
+        case fileModel_1.FileCompareType.LargerOrEqual:
+            return result >= 0;
+        case fileModel_1.FileCompareType.Less:
+            return result < 0;
+        case fileModel_1.FileCompareType.LessOrEqual:
+            return result <= 0;
+    }
+};

package/lib/holidays.d.ts

@@ -0,0 +1,20 @@
+import { PromiseResult } from './result';
+import { DBError } from './errors';
+export default class MarketDateAccess {
+    #private;
+    private static __marketHolidays;
+    private constructor();
+    static getMarketAccess(market: string): PromiseResult<MarketDateAccess, DBError>;
+    isBusinessDay(targetDate: Date): boolean;
+    businessDay(targetDate: Date, dayOffset: number): Date;
+    __getNextBusinessDay(targetDate: Date, dayOffset: number): Date;
+    __getPreviousBusinessDay(targetDate: Date, dayOffset: number): Date;
+    businessDayOfBeginningMonthWithOffset(targetDate: Date, dayOffset?: number): Date;
+    businessDayOfBeginningOfNextMonthWithOffset(targetDate: Date, dayOffset?: number): Date;
+    businessDayOfBeginningOfPreviousMonthWithOffset(targetDate: Date, dayOffset?: number): Date;
+    businessDayOfEndMonthWithOffset(targetDate: Date, dayOffset: number): Date;
+    businessDayOfEndOfNextMonthWithOffset(targetDate: Date, dayOffset: number): Date;
+    businessDayOfEndOfPreviousMonthWithOffset(targetDate: Date, dayOffset: number): Date;
+    businessDayOfBeginningOfYear(targetDate: Date, dayOffset: number): Date;
+    businessDayOfEndOfYear(targetDate: Date, dayOffset: number): Date;
+}