@farris/jit-engine 1.3.230-dev → 1.3.230

package/lib/utility/directory-file-helper.js

@@ -1,242 +1,242 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DirectoryFileHelper = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const environment_constants_1 = require("./environment-constants");
-const line_reader_1 = require("./line-reader");
-const logger_1 = require("./logger");
-class DirectoryFileHelper {
-    static isExists(dirname) {
-        return fs_1.default.existsSync(dirname);
-    }
-    static mkdirsSync(dirname) {
-        if (fs_1.default.existsSync(dirname)) {
-            return true;
-        }
-        else {
-            if (DirectoryFileHelper.mkdirsSync(path_1.default.dirname(dirname))) {
-                fs_1.default.mkdirSync(dirname, 0o777);
-                return true;
-            }
-        }
-    }
-    static copyDir(src, dist, callback) {
-        if (fs_1.default.existsSync(dist) == false) {
-            DirectoryFileHelper.mkdirsSync(dist);
-        }
-        _copy(null, src, dist);
-        function _copy(err, src, dist) {
-            if (err) {
-                callback(err);
-            }
-            else {
-                const dirPath = fs_1.default.readdirSync(src);
-                dirPath.forEach(function (path) {
-                    const _src = src + '/' + path;
-                    const _dist = dist + '/' + path;
-                    const fsState = fs_1.default.statSync(_src);
-                    if (fsState.isFile()) {
-                        fs_1.default.writeFileSync(_dist, fs_1.default.readFileSync(_src));
-                    }
-                    else if (fsState.isDirectory()) {
-                        DirectoryFileHelper.copyDir(_src, _dist, callback);
-                    }
-                });
-            }
-        }
-    }
-    static readJSONFile(filePath, encoding) {
-        const data = this.readFile(filePath, encoding);
-        try {
-            if (data) {
-                return JSON.parse(data);
-            }
-            else {
-                logger_1.LoggerHelper.log(`json file has none data , the file path is ${filePath}`, logger_1.LoggerLevel.Warning);
-            }
-        }
-        catch (ex) {
-            logger_1.LoggerHelper.logWithError(`read json file failed, the file path is ${filePath} !`, ex, logger_1.LoggerLevel.Error);
-            throw ex;
-        }
-    }
-    static readFile(filePath, encoding) {
-        let enc = 'utf8';
-        if (encoding) {
-            enc = encoding;
-        }
-        filePath = DirectoryFileHelper.normalizePath(filePath);
-        if (fs_1.default.existsSync(filePath) == false) {
-            const errorInfo = `file not exist,file path:${filePath}`;
-            throw new Error(errorInfo);
-        }
-        return fs_1.default.readFileSync(filePath, enc);
-    }
-    static deleteFile(filePath, fileName) {
-        this.deleteFileWithAbsoluatePath(path_1.default.join(filePath, fileName));
-    }
-    static deleteFileWithAbsoluatePath(filePath) {
-        if (fs_1.default.existsSync(filePath)) {
-            fs_1.default.unlinkSync(filePath);
-        }
-    }
-    static deleteFolder(dirPath) {
-        if (!fs_1.default.existsSync(dirPath)) {
-            return;
-        }
-        const isSymbolLink = fs_1.default.lstatSync(dirPath).isSymbolicLink();
-        if (isSymbolLink) {
-            fs_1.default.unlinkSync(dirPath);
-        }
-        else {
-            fs_1.default.rmdirSync(dirPath);
-        }
-    }
-    static deleteFolderRecursive(folder, outDetail = false, onlyDeleteSymbolLink = true) {
-        if (fs_1.default.existsSync(folder)) {
-            if (fs_1.default.statSync(folder).isDirectory()) {
-                fs_1.default.readdirSync(folder).forEach(function (file) {
-                    const curPath = path_1.default.join(folder, file);
-                    if (fs_1.default.statSync(curPath).isDirectory()) {
-                        const isSymbolLink = fs_1.default.lstatSync(curPath).isSymbolicLink();
-                        if (onlyDeleteSymbolLink && isSymbolLink) {
-                            DirectoryFileHelper.unLinkSync(curPath);
-                        }
-                        else {
-                            DirectoryFileHelper.deleteFolderRecursive(curPath);
-                        }
-                    }
-                    else {
-                        if (outDetail) {
-                            logger_1.LoggerHelper.log(`delete:${curPath}`);
-                        }
-                        DirectoryFileHelper.unLinkSync(curPath);
-                    }
-                });
-                if (outDetail) {
-                    logger_1.LoggerHelper.log(`delete:${folder}`);
-                }
-                fs_1.default.rmdirSync(folder);
-            }
-            else {
-                if (outDetail) {
-                    logger_1.LoggerHelper.log(`delete:${folder}`);
-                }
-                DirectoryFileHelper.unLinkSync(folder);
-            }
-        }
-    }
-    static unLinkSync(path) {
-        if (fs_1.default.existsSync(path)) {
-            fs_1.default.unlinkSync(path);
-        }
-    }
-    static copyFile(sourceFilePath, sourceFileName, targetFilePath, targetFileName) {
-        const sourceFile = path_1.default.join(sourceFilePath, sourceFileName);
-        if (this.isExists(sourceFile)) {
-            fs_1.default.copyFile(sourceFile, path_1.default.join(targetFilePath, targetFileName), (err) => {
-                if (err)
-                    throw err;
-            });
-        }
-    }
-    static createFile(filePath, fileName, content, isSync = false) {
-        if (fs_1.default.existsSync(filePath) == false) {
-            DirectoryFileHelper.mkdirsSync(filePath);
-        }
-        const executeEnvironment = environment_constants_1.EnvironmentConstants.getExecuteEnvironment();
-        let mustSync = false;
-        if (executeEnvironment && executeEnvironment == "UnitTest") {
-            mustSync = true;
-        }
-        const fileNameAndPath = path_1.default.join(filePath, fileName);
-        if (isSync == false) {
-            if (mustSync == false) {
-                fs_1.default.writeFile(fileNameAndPath, content, {
-                    encoding: 'utf8'
-                }, function (err) {
-                    if (err) {
-                        console.log('create file failed,error message is ' + err);
-                        throw err;
-                    }
-                });
-            }
-            else {
-                fs_1.default.writeFileSync(fileNameAndPath, content, { encoding: 'utf8' });
-            }
-        }
-        else {
-            fs_1.default.writeFileSync(fileNameAndPath, content, { encoding: 'utf8' });
-        }
-    }
-    static normalizePath(sourceFilePath) {
-        return path_1.default.normalize(sourceFilePath);
-    }
-    static readFileByLine(filePath, removeEmpty = true, encoding) {
-        if (fs_1.default.existsSync(filePath) == false) {
-            return;
-        }
-        const lineReader = new line_reader_1.LineReader(filePath);
-        try {
-            lineReader.open();
-            const lines = [];
-            while (!lineReader._EOF) {
-                const nextLine = lineReader.next();
-                if (removeEmpty) {
-                    if (nextLine && nextLine.trim().length > 0) {
-                        lines.push(nextLine);
-                    }
-                }
-                else {
-                    lines.push(nextLine);
-                }
-            }
-            return lines;
-        }
-        finally {
-            lineReader.close();
-        }
-    }
-    static getRelativePath(sourcePath, targetPath) {
-        return path_1.default.relative(sourcePath, targetPath);
-    }
-    static getFilesInDir(dirPath) {
-        if (fs_1.default.existsSync(dirPath)) {
-            return fs_1.default.readdirSync(dirPath);
-        }
-    }
-    static isEmptyDir(dirPath) {
-        if (fs_1.default.existsSync(dirPath) && fs_1.default.statSync(dirPath).isDirectory()) {
-            const fileList = fs_1.default.readdirSync(dirPath);
-            return fileList != null && fileList.length == 0;
-        }
-        return false;
-    }
-    static rescureDir(dirPath, action) {
-        if (fs_1.default.existsSync(dirPath) == false) {
-            return;
-        }
-        if (fs_1.default.statSync(dirPath).isDirectory()) {
-            fs_1.default.readdirSync(dirPath).forEach(function (file) {
-                const curPath = path_1.default.join(dirPath, file);
-                if (fs_1.default.statSync(curPath).isDirectory()) {
-                    DirectoryFileHelper.rescureDir(curPath, action);
-                    action(curPath, true);
-                }
-                else {
-                    action(curPath, false);
-                }
-            });
-            action(dirPath, true);
-        }
-        else {
-            action(dirPath, false);
-        }
-    }
-}
-exports.DirectoryFileHelper = DirectoryFileHelper;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectoryFileHelper = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const environment_constants_1 = require("./environment-constants");
+const line_reader_1 = require("./line-reader");
+const logger_1 = require("./logger");
+class DirectoryFileHelper {
+    static isExists(dirname) {
+        return fs_1.default.existsSync(dirname);
+    }
+    static mkdirsSync(dirname) {
+        if (fs_1.default.existsSync(dirname)) {
+            return true;
+        }
+        else {
+            if (DirectoryFileHelper.mkdirsSync(path_1.default.dirname(dirname))) {
+                fs_1.default.mkdirSync(dirname, 0o777);
+                return true;
+            }
+        }
+    }
+    static copyDir(src, dist, callback) {
+        if (fs_1.default.existsSync(dist) == false) {
+            DirectoryFileHelper.mkdirsSync(dist);
+        }
+        _copy(null, src, dist);
+        function _copy(err, src, dist) {
+            if (err) {
+                callback(err);
+            }
+            else {
+                const dirPath = fs_1.default.readdirSync(src);
+                dirPath.forEach(function (path) {
+                    const _src = src + '/' + path;
+                    const _dist = dist + '/' + path;
+                    const fsState = fs_1.default.statSync(_src);
+                    if (fsState.isFile()) {
+                        fs_1.default.writeFileSync(_dist, fs_1.default.readFileSync(_src));
+                    }
+                    else if (fsState.isDirectory()) {
+                        DirectoryFileHelper.copyDir(_src, _dist, callback);
+                    }
+                });
+            }
+        }
+    }
+    static readJSONFile(filePath, encoding) {
+        const data = this.readFile(filePath, encoding);
+        try {
+            if (data) {
+                return JSON.parse(data);
+            }
+            else {
+                logger_1.LoggerHelper.log(`json file has none data , the file path is ${filePath}`, logger_1.LoggerLevel.Warning);
+            }
+        }
+        catch (ex) {
+            logger_1.LoggerHelper.logWithError(`read json file failed, the file path is ${filePath} !`, ex, logger_1.LoggerLevel.Error);
+            throw ex;
+        }
+    }
+    static readFile(filePath, encoding) {
+        let enc = 'utf8';
+        if (encoding) {
+            enc = encoding;
+        }
+        filePath = DirectoryFileHelper.normalizePath(filePath);
+        if (fs_1.default.existsSync(filePath) == false) {
+            const errorInfo = `file not exist,file path:${filePath}`;
+            throw new Error(errorInfo);
+        }
+        return fs_1.default.readFileSync(filePath, enc);
+    }
+    static deleteFile(filePath, fileName) {
+        this.deleteFileWithAbsoluatePath(path_1.default.join(filePath, fileName));
+    }
+    static deleteFileWithAbsoluatePath(filePath) {
+        if (fs_1.default.existsSync(filePath)) {
+            fs_1.default.unlinkSync(filePath);
+        }
+    }
+    static deleteFolder(dirPath) {
+        if (!fs_1.default.existsSync(dirPath)) {
+            return;
+        }
+        const isSymbolLink = fs_1.default.lstatSync(dirPath).isSymbolicLink();
+        if (isSymbolLink) {
+            fs_1.default.unlinkSync(dirPath);
+        }
+        else {
+            fs_1.default.rmdirSync(dirPath);
+        }
+    }
+    static deleteFolderRecursive(folder, outDetail = false, onlyDeleteSymbolLink = true) {
+        if (fs_1.default.existsSync(folder)) {
+            if (fs_1.default.statSync(folder).isDirectory()) {
+                fs_1.default.readdirSync(folder).forEach(function (file) {
+                    const curPath = path_1.default.join(folder, file);
+                    if (fs_1.default.statSync(curPath).isDirectory()) {
+                        const isSymbolLink = fs_1.default.lstatSync(curPath).isSymbolicLink();
+                        if (onlyDeleteSymbolLink && isSymbolLink) {
+                            DirectoryFileHelper.unLinkSync(curPath);
+                        }
+                        else {
+                            DirectoryFileHelper.deleteFolderRecursive(curPath);
+                        }
+                    }
+                    else {
+                        if (outDetail) {
+                            logger_1.LoggerHelper.log(`delete:${curPath}`);
+                        }
+                        DirectoryFileHelper.unLinkSync(curPath);
+                    }
+                });
+                if (outDetail) {
+                    logger_1.LoggerHelper.log(`delete:${folder}`);
+                }
+                fs_1.default.rmdirSync(folder);
+            }
+            else {
+                if (outDetail) {
+                    logger_1.LoggerHelper.log(`delete:${folder}`);
+                }
+                DirectoryFileHelper.unLinkSync(folder);
+            }
+        }
+    }
+    static unLinkSync(path) {
+        if (fs_1.default.existsSync(path)) {
+            fs_1.default.unlinkSync(path);
+        }
+    }
+    static copyFile(sourceFilePath, sourceFileName, targetFilePath, targetFileName) {
+        const sourceFile = path_1.default.join(sourceFilePath, sourceFileName);
+        if (this.isExists(sourceFile)) {
+            fs_1.default.copyFile(sourceFile, path_1.default.join(targetFilePath, targetFileName), (err) => {
+                if (err)
+                    throw err;
+            });
+        }
+    }
+    static createFile(filePath, fileName, content, isSync = false) {
+        if (fs_1.default.existsSync(filePath) == false) {
+            DirectoryFileHelper.mkdirsSync(filePath);
+        }
+        const executeEnvironment = environment_constants_1.EnvironmentConstants.getExecuteEnvironment();
+        let mustSync = false;
+        if (executeEnvironment && executeEnvironment == "UnitTest") {
+            mustSync = true;
+        }
+        const fileNameAndPath = path_1.default.join(filePath, fileName);
+        if (isSync == false) {
+            if (mustSync == false) {
+                fs_1.default.writeFile(fileNameAndPath, content, {
+                    encoding: 'utf8'
+                }, function (err) {
+                    if (err) {
+                        console.log('create file failed,error message is ' + err);
+                        throw err;
+                    }
+                });
+            }
+            else {
+                fs_1.default.writeFileSync(fileNameAndPath, content, { encoding: 'utf8' });
+            }
+        }
+        else {
+            fs_1.default.writeFileSync(fileNameAndPath, content, { encoding: 'utf8' });
+        }
+    }
+    static normalizePath(sourceFilePath) {
+        return path_1.default.normalize(sourceFilePath);
+    }
+    static readFileByLine(filePath, removeEmpty = true, encoding) {
+        if (fs_1.default.existsSync(filePath) == false) {
+            return;
+        }
+        const lineReader = new line_reader_1.LineReader(filePath);
+        try {
+            lineReader.open();
+            const lines = [];
+            while (!lineReader._EOF) {
+                const nextLine = lineReader.next();
+                if (removeEmpty) {
+                    if (nextLine && nextLine.trim().length > 0) {
+                        lines.push(nextLine);
+                    }
+                }
+                else {
+                    lines.push(nextLine);
+                }
+            }
+            return lines;
+        }
+        finally {
+            lineReader.close();
+        }
+    }
+    static getRelativePath(sourcePath, targetPath) {
+        return path_1.default.relative(sourcePath, targetPath);
+    }
+    static getFilesInDir(dirPath) {
+        if (fs_1.default.existsSync(dirPath)) {
+            return fs_1.default.readdirSync(dirPath);
+        }
+    }
+    static isEmptyDir(dirPath) {
+        if (fs_1.default.existsSync(dirPath) && fs_1.default.statSync(dirPath).isDirectory()) {
+            const fileList = fs_1.default.readdirSync(dirPath);
+            return fileList != null && fileList.length == 0;
+        }
+        return false;
+    }
+    static rescureDir(dirPath, action) {
+        if (fs_1.default.existsSync(dirPath) == false) {
+            return;
+        }
+        if (fs_1.default.statSync(dirPath).isDirectory()) {
+            fs_1.default.readdirSync(dirPath).forEach(function (file) {
+                const curPath = path_1.default.join(dirPath, file);
+                if (fs_1.default.statSync(curPath).isDirectory()) {
+                    DirectoryFileHelper.rescureDir(curPath, action);
+                    action(curPath, true);
+                }
+                else {
+                    action(curPath, false);
+                }
+            });
+            action(dirPath, true);
+        }
+        else {
+            action(dirPath, false);
+        }
+    }
+}
+exports.DirectoryFileHelper = DirectoryFileHelper;
 //# sourceMappingURL=directory-file-helper.js.map

package/lib/utility/employee-selector-checker.js

@@ -1,58 +1,58 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EmployeeSelectorChecker = void 0;
-const toolhepler_1 = require("./toolhepler");
-class EmployeeSelectorChecker {
-    constructor() { }
-    static checkIsEmployeeSelector(ui, employeeSelector) {
-        if ((employeeSelector.isEmployeeSelector == false || employeeSelector.isGridEmployeeSelector == false) &&
-            ui.module && toolhepler_1.ToolHelper.isArray(ui.module.components, false)) {
-            employeeSelector.isEmployeeSelector = !!employeeSelector.isEmployeeSelector;
-            employeeSelector.isGridEmployeeSelector = !!employeeSelector.isGridEmployeeSelector;
-            ui.module.components.forEach((item) => {
-                if (employeeSelector.isEmployeeSelector == false || employeeSelector.isGridEmployeeSelector == false) {
-                    this.checkHasEmployeeSelector(employeeSelector, item, null);
-                }
-            });
-        }
-    }
-    static checkHasEmployeeSelector(obj, component, contents) {
-        if (component) {
-            this.checkHasEmployeeSelectorType(component, obj);
-        }
-        else if (toolhepler_1.ToolHelper.isArray(contents, false)) {
-            for (let i = 0; i < contents.length; i++) {
-                this.checkHasEmployeeSelectorType(contents[i], obj);
-            }
-        }
-    }
-    static checkHasEmployeeSelectorType(component, obj) {
-        var _a;
-        if (component.type == this.employeeSelectorType) {
-            obj.isEmployeeSelector = true;
-        }
-        else if (((_a = component.editor) === null || _a === void 0 ? void 0 : _a.type) == this.employeeSelectorType) {
-            obj.isGridEmployeeSelector = true;
-        }
-        if (component.contents && component.contents.length) {
-            this.checkHasEmployeeSelector(obj, null, component.contents);
-        }
-        else if (obj.isGridEmployeeSelector == false && toolhepler_1.ToolHelper.isArray(component.fields, false)) {
-            this.checkHasEmployeeSelector(obj, null, component.fields);
-        }
-        else if (component && toolhepler_1.ToolHelper.isArray(component.rows, false)) {
-            component.rows.forEach((element) => {
-                if (toolhepler_1.ToolHelper.isArray(element.columns, false)) {
-                    element.columns.forEach((elementColumn) => {
-                        if (elementColumn.editor) {
-                            this.checkHasEmployeeSelectorType(elementColumn.editor, obj);
-                        }
-                    });
-                }
-            });
-        }
-    }
-}
-exports.EmployeeSelectorChecker = EmployeeSelectorChecker;
-EmployeeSelectorChecker.employeeSelectorType = "EmployeeSelector";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmployeeSelectorChecker = void 0;
+const toolhepler_1 = require("./toolhepler");
+class EmployeeSelectorChecker {
+    constructor() { }
+    static checkIsEmployeeSelector(ui, employeeSelector) {
+        if ((employeeSelector.isEmployeeSelector == false || employeeSelector.isGridEmployeeSelector == false) &&
+            ui.module && toolhepler_1.ToolHelper.isArray(ui.module.components, false)) {
+            employeeSelector.isEmployeeSelector = !!employeeSelector.isEmployeeSelector;
+            employeeSelector.isGridEmployeeSelector = !!employeeSelector.isGridEmployeeSelector;
+            ui.module.components.forEach((item) => {
+                if (employeeSelector.isEmployeeSelector == false || employeeSelector.isGridEmployeeSelector == false) {
+                    this.checkHasEmployeeSelector(employeeSelector, item, null);
+                }
+            });
+        }
+    }
+    static checkHasEmployeeSelector(obj, component, contents) {
+        if (component) {
+            this.checkHasEmployeeSelectorType(component, obj);
+        }
+        else if (toolhepler_1.ToolHelper.isArray(contents, false)) {
+            for (let i = 0; i < contents.length; i++) {
+                this.checkHasEmployeeSelectorType(contents[i], obj);
+            }
+        }
+    }
+    static checkHasEmployeeSelectorType(component, obj) {
+        var _a;
+        if (component.type == this.employeeSelectorType) {
+            obj.isEmployeeSelector = true;
+        }
+        else if (((_a = component.editor) === null || _a === void 0 ? void 0 : _a.type) == this.employeeSelectorType) {
+            obj.isGridEmployeeSelector = true;
+        }
+        if (component.contents && component.contents.length) {
+            this.checkHasEmployeeSelector(obj, null, component.contents);
+        }
+        else if (obj.isGridEmployeeSelector == false && toolhepler_1.ToolHelper.isArray(component.fields, false)) {
+            this.checkHasEmployeeSelector(obj, null, component.fields);
+        }
+        else if (component && toolhepler_1.ToolHelper.isArray(component.rows, false)) {
+            component.rows.forEach((element) => {
+                if (toolhepler_1.ToolHelper.isArray(element.columns, false)) {
+                    element.columns.forEach((elementColumn) => {
+                        if (elementColumn.editor) {
+                            this.checkHasEmployeeSelectorType(elementColumn.editor, obj);
+                        }
+                    });
+                }
+            });
+        }
+    }
+}
+exports.EmployeeSelectorChecker = EmployeeSelectorChecker;
+EmployeeSelectorChecker.employeeSelectorType = "EmployeeSelector";
 //# sourceMappingURL=employee-selector-checker.js.map