momo-ai 1.0.0 → 1.0.1

package/src/epic/history/ai.unified.fn.fn.error.code.js

@@ -0,0 +1,108 @@
+/**
+ * ## `Ec.E`
+ *
+ * ### 1. 基本介绍
+ *
+ * 该类为错误信息定义专用类，方法名采用`fn<Code>`的方式执行最终输出的错误信息内容。通常使用下边代码：
+ *
+ * ```js
+ * // 第一种调用方法：第一参直接是错误代码
+ * Ec.fxError(10001, arg1, arg2);
+ *
+ * // 第二种调用方法：第一参是Boolean值，true就输出，第二参是错误代码
+ * const checked = true;
+ * Ec.fxError(checked, 10001, arg1, arg2);
+ *
+ * // 第三种调用方法：第一参是Function，执行后结果为true就输出，第二参是错误代码
+ * const fnChecked = () => true;
+ * Ec.fxError(fnChecked, 10001, arg1, arg2);
+ * ```
+ *
+ * ### 2. 错误代码表
+ *
+ * |代码|参数表|含义|
+ * |---|---|:---|
+ * |10001|`arg,type`|输入参数类型不匹配。|
+ * |10002|`arg,type,expected`|「带期望」输入参数和期望参数不匹配。|
+ * |10003|`fileType`|文件类型无法被解析。|
+ * |10004|`command`|无法识别命令名，不在可解析的命令中。|
+ * |10005|`command,expected`|「带期望」输入的命令不在期望的命令列表中。|
+ * |10006|`arg`|命令执行中丢失了必须的参数。|
+ * |10007|`path`|输入的目录不存在，或者输入路径并不是一个目录。|
+ * |10008|`path`|目录不存在，或输入路径是一个文件。|
+ * |10009|`path`|路径直接不存在，不论目录还是文件都不存在。|
+ * |10010|`projects`|系统检测到两个或两个以上的项目目录，系统无法定位操作项目环境。|
+ * |10011|`config`|「后端」配置数据中丢失了`api`属性值。|
+ * |10012|`member,clazz`|「后端」在查找的`clazz`类名中无法找到（成员变量/成员函数）`member`。|
+ * |10013|`lineType`|工具无法分析行类型，输入的文件内容不符合Zero Ai的基本规范，无法解析源代码。|
+ * |10014|`pkg`|「后端」系统找到了超过两个以上的`package`语句，这个在定义过程中是非法的，不可连续执行。|
+ * |10015|`method,clazz`|「后端」在查找的`clazz`类名中找到了重复的（成员函数/成员变量）`method`，所以非法。|
+ * |10016|`command`|「前端」Zero UI规范错误，不可执行当前命令。|
+ * |10017|`root`|「前端」Zero项目的目录并非一个合法的项目目录，请定位到合法的项目目录中。|
+ * |10018|`resource`|「前端」资源文件绑定过程中出现了资源错误，请检查环境或执行命令。|
+ * |10019|`root`|「前端」当前命令只能在项目根目录中执行（带有package.json文件），其他目录不可执行该方法。|
+ * |10020|`menuData`|「前端」当前菜单数据必须是一个合法的Array类型，当前类型不对。|
+ * |10021|`field,value`|条件`field=value`引起了重复数据记录，导致不匹配UK规范，检查重复数据专用错误。|
+ * |10022|`root`|「前端/后端」无法定位项目的根目录，不可执行项目专用类命令。|
+ * |10023|`folder`|「前端」初始化项目时检测到输入的文件路径是一个非空目录，不可执行Zero AI的初始化。|
+ * |10024|`path`|当前操作和输入的路径冲突，不可在路径中执行操作指令。|
+ * |10025|`configKey`|「前端」配置项主键丢失了核心配置，在生成前端Web组件时出现了规范冲突。|
+ * |10026|`path`|「前端」输入路径非法，不在支持的Zero Ui专用路径规范中。|
+ * |10027|`modulePath`|「前端」输入路径必须是`<module>/<page>`格式，当前路径并非该格式，和规范冲突。|
+ * |10028|`arg`|「前端」模块参数不在枚举值中，必须是四者之一：`FORM, FILTER, HALF, EDIT`。|
+ * |10029|`zt`|「带期望」环境变量缺失或者格式不对，必须是`<module>/<page>`格式。|
+ * |10030|`arg, key`|「开发专用」方法要求资源文件中必须包含`key`属性，当前`key`属性值不对。|
+ * |10031|`id`|「开发专用」当前HTML按钮元素要求`btn`前缀，输入前缀不合法。|
+ * |10032|`platform`|操作系统不支持当前命令，或者该操作系统平台中还未实现该命令的执行逻辑。|
+ * |10033|`path`|当前路径不符合Zero专用规范（基础Java/Maven规范）。|
+ * |10034|`path`|当前路径不符合Ox平台专用规范。|
+ *
+ * @class E
+ */
+module.exports = {
+    // 基础
+    fn10001: (arg, type) => `[AI-10001] Argument must be '${type}', but now it's '${arg}'`,
+    fn10002: (arg, type, expected) => `[AI-10002] Argument must be in (${expected}), but now it's '${arg}' of '${type}'`,
+
+    // 命令
+    fn10003: (fileType) => `[AI-10003] The fileType='${fileType}' is unknown and could not found parser`,
+    fn10004: (command) => `[AI-10004] The executor of command '${command}' could not be found（执行器丢失）`,
+    fn10005: (command = "未输入", expected) => `[AI-10005] The command '${command}' could not be found, expected '${expected}'`,
+    fn10006: (arg) => `[AI-10006] The command missed required arguments: '${arg}'`,
+
+    // 路径
+    fn10007: (path) => `[AI-10007] The file '${path}' does not exist or it's a directory.`,
+    fn10008: (path) => `[AI-10008] The directory '${path}' does not exist or it's a file.`,
+    fn10009: (path) => `[AI-10009] The path '${path}' does not exist.`,
+
+    // 后端
+    fn10010: (projects = []) => `[AI-10010] The tool detect more than one project folders, found '${projects.length}', please switch.`,
+    fn10011: (config) => `[AI-10011] 'api' attribute has been missed in current config ${JSON.stringify(config)}`,
+    fn10012: (member, clazz) => `[AI-10012] Duplicated member '${member}' found in class '${clazz}', please check.`,
+    fn10013: (lineType) => `[AI-10013] Zero system could not analyze the code line type, type = ${lineType} is Unknown`,
+    fn10014: (pkg) => `[AI-10014] More than one 'package' sentence found.${JSON.stringify(pkg)}`,
+    fn10015: (method, clazz) => `[AI-10015] Duplicated method '${method}' found in class '${clazz}', please check.`,
+
+    // 前端
+    fn10016: (command) => `[AI-10016] Zero UI specification wrong, you could not execute in '${command}'`,
+    fn10017: (root) => `[AI-10017] Current folder '${root}' is not project folder, please switch to project root directory`,
+    fn10018: (resource) => `[AI-10018] Zero Resource config file missing '${resource}', please check.`,
+    fn10019: (root) => `[AI-10019] This command could run in project root folder only, current folder = ${root}`,
+    fn10020: (menuData) => `[AI-10020] The menu data file must be json format with 'data' (Array) node, current = ${menuData}`,
+    fn10021: (field, value) => `[AI-10021] The condition '${field} = ${value}' hit duplicated record in your file.`,
+    fn10022: (root) => `[AI-10022] Could not find root folder of current project. ${root}`,
+    fn10023: (folder) => `[AI-10023] Initialized folder must be empty, current ${folder} is invalid`,
+    fn10024: (path) => `[AI-10024] This operation is not allowed for current path ${path}`,
+    fn10025: (configKey) => `[AI-10025] Web control initialized require "actual.data" must be string, current:${configKey}`,
+    fn10026: (path) => `[AI-10026] The path is invalid, ${path}, system support one of ".", "src/components/xxx", "xxx".`,
+    fn10027: (modulePath) => `[AI-10027] The path must be formatted with "<module>/<page>", could not be others, current = ${modulePath}`,
+    fn10028: (arg) => `[AI-10028] The "module" parameter must be one of "FORM", "FILTER", "HALF", "EDIT" values. current = ${arg}`,
+    fn10029: (zt, name) => `[AI-10029] [DEV] You'll use development command, please set "${name}" environment first, current = ${zt}. React format = "<module>/<page>", Java for other.`,
+    fn10030: (arg, key) => `[AI-10030] [DEV] This method require "${key}" in your resource file, but current "${key}" = ${arg}`,
+    fn10031: (id) => `[AI-10031] [DEV] Button key must start with "btn", current ${id}`,
+    fn10032: (platform) => `[AI-10032] This api is not implemented in current platform os.platform() -> '${platform}'`,
+    fn10033: (path) => `[AI-10033] (Zero) Current path '${path}' is not correct Zero work folder under specification`,
+    fn10034: (path) => `[AI-10034] (Ox) Current path '${path}' is not correct Ox work folder`,
+    fn10035: (path) => `[AI-10035] (Mod) The "initialize.json" configuration file has been missed in '${path}'`,
+    fn10036: (mode) => `[AI-10036] (Mod) The mode must be in "REPLACE, APPEND", could not been parsed: ${mode}`,
+};

package/src/epic/history/ai.unified.fn.is.decision.js

@@ -0,0 +1,20 @@
+const fs = require('fs');
+const U = require("underscore");
+const isFile = (path) => {
+    if (fs.existsSync(path)) {
+        return fs.statSync(path).isFile();
+    }
+};
+const isDirectory = (path) => {
+    if (fs.existsSync(path)) {
+        return fs.statSync(path).isDirectory();
+    }
+};
+const isExist = (path) => fs.existsSync(path);
+
+module.exports = {
+    isExist,
+    isFile,
+    isDirectory,
+    isFunction: (input) => U.isFunction(input),
+}

package/src/epic/history/ai.unified.fn.sorter.element.js

@@ -0,0 +1,26 @@
+const sortString = (left = "", right = "", asc = true) => {
+    const minLen = Math.max(left.length, right.length);
+    let order = 0;
+    for (let idx = 0; idx < minLen; idx++) {
+        let leftCode = left.charCodeAt(idx);
+        let rightCode = right.charCodeAt(idx);
+        // 空白的处理
+        if (leftCode !== rightCode) {
+            // 修正长度不等的时候的基础算法
+            if (isNaN(leftCode)) leftCode = 0;
+            if (isNaN(rightCode)) rightCode = 0;
+            if (asc) {
+                order = leftCode - rightCode;
+            } else {
+                order = rightCode - leftCode;
+            }
+            break;
+        }
+    }
+    return order;
+};
+
+module.exports = {
+    sorterSAsc: (left, right) => sortString(left, right, true),
+    sorterSDesc: (left, right) => sortString(left, right, false),
+}

package/src/epic/history/zero.__.fn.find.util.js

@@ -0,0 +1,37 @@
+const os = require("os");
+const _V = require('./zero.__.v.constant');
+
+const findTrace = (path = "") => {
+    const folderTrace = path.split(_V.FILE_DELIMITER).filter(each => '' !== each);
+    const folderInfo = [];
+    folderTrace.forEach((trace, index) => {
+        const formatted = `${_V.FILE_DELIMITER}${trace}`;
+        const previous = folderInfo[index - 1];
+        let item = null;
+        if (previous) {
+            item = `${previous}${formatted}`;
+        } else {
+            if (os.platform() === 'win32') {
+                item = `${trace}`
+            } else {
+                item = `${formatted}`;
+            }
+        }
+        folderInfo.push(item);
+    });
+    return folderInfo
+};
+const findMaxFields = (array = []) => {
+    let keys = {};
+    for (let idx = 0; idx < array.length; idx++) {
+        const length = Object.keys(array[idx]).length;
+        if (length > Object.keys(keys).length) {
+            keys = array[idx];
+        }
+    }
+    return Object.keys(keys);
+};
+module.exports = {
+    findTrace,
+    findMaxFields,
+}

package/src/epic/history/zero.__.v.constant.js

@@ -0,0 +1,5 @@
+const path = require('path');
+
+module.exports = {
+    FILE_DELIMITER: path.sep,
+}

package/src/epic/index.js

@@ -0,0 +1,50 @@
+const Log = require("./momo.fn.log");
+
+const func_element = require('./momo.fn.element');
+const func_it = require('./momo.fn.it');
+const func_cx = require('./momo.fn.cx');
+const func_fx = require('./momo.fn.fx');
+const func_sorter = require("./momo.fn.sorter");
+const func_str = require("./momo.fn.str");
+
+const func_is = require("./momo.fn.is");
+const func_dir = require("./momo.fn.dir");
+const func_to = require("./momo.fn.to");
+const func_io = require("./momo.fn.io");
+const func_out = require("./momo.fn.out");
+
+const Immutable = require("immutable");
+
+const lain_execute = require("./lain.fn.execute");
+const lain_parse = require("./lain.fn.parse");
+
+const exported = {
+    ...func_is,
+    ...func_dir,
+    ...func_to,
+    ...func_io,
+    ...func_out,
+
+    ...func_str,
+    // Util
+    ...func_element,
+    ...func_it,
+    ...func_cx,
+    ...func_fx,
+    ...func_sorter,
+    // clone method
+    clone: input => Immutable.fromJS(input).toJS(),
+    info: Log.info,
+    error: Log.error,
+    warn: Log.warn,
+    waiting: Log.execute,
+    ask: Log.ask,
+    askClose: Log.askClose,
+
+    ...lain_execute,
+    ...lain_parse
+};
+/**
+ * @module _epic
+ **/
+module.exports = exported;

package/src/epic/lain.fn.execute.js

@@ -0,0 +1,116 @@
+const program = require('commander');
+const U = require('underscore');
+const co = require('co');
+const Immutable = require('immutable');
+const __LOG = require('./momo.fn.log');
+const __IT = require('./momo.fn.it');
+const __FX = require('./momo.fn.fx');
+
+
+const _buildOption = (options = []) => {
+    let optionStr = "";
+    const optionItem = [];
+    options.forEach((option, index) => {
+        const keys = Object.keys(option);
+        const key0 = keys[0].toString();
+        const key1 = keys[1] ? keys[1].toString() : undefined;
+        if (key1) {
+            const short = key0.length < key1.length ? key0 : key1;
+            const long = key0.length > key1.length ? key0 : key1;
+            const key = `-${short}, --${long}`;
+            const opt = {};
+            opt.key = key;
+            opt.desc = option[short] ? option[short] : option[long];
+            optionItem.push(opt);
+            optionStr += key;
+            if (index < options.length - 1) {
+                optionStr += ' | ';
+            }
+        }
+    });
+    return {
+        item: optionItem,
+        usage: optionStr
+    };
+};
+
+const _validateArgs = (keys = []) => {
+    const commandArg = process.argv[2];
+    const skip = Immutable.fromJS(["-h", '-V', '--version', '--help']);
+    if (!skip.contains(commandArg)) {
+        const $keys = Immutable.fromJS(keys.concat(['help']));
+        const isError = !$keys.contains(commandArg);
+        // 检测未通过时，打印错误信息
+        __FX.fxError(isError, 10005, commandArg, keys);
+        return !isError;
+    } else {
+        // 直接跳过，检测未通过
+        return false;
+    }
+};
+/**
+ * ## `Ec.executeHeader`
+ *
+ * 执行命令时打印头信息
+ *
+ * @memberOf module:_epic
+ * @param {String} app 应用程序名
+ */
+const executeHeader = (app) => {
+    const appInfo = require('../../package.json');
+    program.allowUnknownOption();
+    program.version(appInfo.version);
+    __LOG.info(`----------------- Rachel Momo / AI工具项  ------------------`.rainbow);
+    __LOG.info('应用名称: '.bold + app);
+    __LOG.info('工具主页: '.bold + appInfo.homepage.blue);
+    __LOG.info(`工具版本: ` + `${appInfo.version}`.red + '  ' + `( Node >= 22.x )`.yellow);
+    __LOG.info();
+    __LOG.info("----------------- AI 系统启动…… ----------------------------".rainbow);
+    if (3 > process.argv.length) {
+        __LOG.error("命令缺失，请输入正确的命令！");
+    }
+};
+/**
+ * ## `Ec.executeBody`
+ *
+ * 执行命令的主方法
+ *
+ * @memberOf module:_epic
+ * @param {Array} commanders 指令集
+ * @param {Object} Executor 指令执行集`field = Function`格式
+ */
+const executeBody = (commanders = [], Executor = {}) => {
+    if (_validateArgs(commanders.map(commander => commander.command))) {
+        __IT.itArray(commanders, (commander) => {
+            if (!commander.options) commander.options = [];
+            const executor = Executor[commander.executor];
+            __FX.fxError(!U.isFunction(executor), 10004, commander.command);
+            const option = _buildOption(commander.options);
+            const cmd = program.command(commander.command)
+                .description(commander.description)
+                .usage(`[options] [${option.usage}]`);
+            __FX.fxContinue(0 < commander.options.length, () => {
+                // 设置选项
+                commander.options.forEach(option => {
+                    cmd.option(`-${option.alias}`, option.description);
+                    cmd.option(`--${option.name}`, option.description);
+                })
+            });
+            cmd.action(() => co(() => executor(commander.options)));
+        });
+    }
+};
+/**
+ * ## `Ec.executeEnd`
+ *
+ * @memberOf module:_epic
+ * 执行命令时打印尾信息
+ */
+const executeEnd = () => {
+    program.parse(process.argv);
+};
+module.exports = {
+    executeHeader,
+    executeBody,
+    executeEnd,
+};

package/src/epic/lain.fn.parse.js

@@ -0,0 +1,94 @@
+const _IO = require("./momo.fn.io");
+
+const parseMetadata = () => {
+    const commandMeta = _IO.ioRoot() + "/commander";
+    const commandFiles = _IO.ioFiles(commandMeta);
+    const commandList = [];
+    commandFiles.forEach(fileObj => {
+        const filename = fileObj.file.toString();
+        if (filename.endsWith(".json")) {
+            const command = filename.substring(0, filename.indexOf("."));
+            const commandPath = _IO.ioRoot() + "/commander/" + command + ".json";
+            const commandJ = _IO.ioJObject(commandPath);
+            commandList.push(commandJ);
+        }
+    });
+    return commandList;
+}
+
+const parseArgument = (options = []) => {
+    const args = process.argv.splice(3);
+    const result = {};
+    const argsLength = args.length;
+
+    // 将 options 转换为 map 以便快速查找
+    const optionsMap = new Map();
+    const aliasesMap = new Map();
+
+    options.forEach(option => {
+        optionsMap.set(option.name, option);
+        if (option.alias) {
+            aliasesMap.set(option.alias, option);
+        }
+    });
+
+    // 解析参数
+    for (let i = 0; i < argsLength; i += 2) {
+        const key = args[i];
+        const value = args[i + 1];
+
+        if (!key || !value) {
+            // 如果参数不成对，报错
+            if (key && !value) {
+                throw new Error(`[ ZERO ] 缺少参数 ${key} 的值`);
+            }
+            break;
+        }
+
+        // 移除前缀（- 或 --）
+        let cleanKey = key;
+        if (key.startsWith('--')) {
+            cleanKey = key.substring(2);
+        } else if (key.startsWith('-')) {
+            cleanKey = key.substring(1);
+        }
+
+        // 查找对应的选项
+        const option = optionsMap.get(cleanKey) || aliasesMap.get(cleanKey);
+
+        if (!option) {
+            throw new Error(`[ ZERO ] 未知的参数: ${key}`);
+        }
+
+        // 转换值的类型
+        let parsedValue = value;
+        if (option.type === 'number') {
+            parsedValue = Number(value);
+            if (isNaN(parsedValue)) {
+                throw new Error(`[ ZERO ] 参数 ${key} 的值 ${value} 不是有效的数字`);
+            }
+        } else if (option.type === 'boolean') {
+            parsedValue = value.toLowerCase() === 'true';
+        }
+
+        result[option.name] = parsedValue;
+    }
+
+    // 处理默认值和必需参数
+    options.forEach(option => {
+        const key = option.name;
+        if (!(key in result)) {
+            if ('default' in option) {
+                result[key] = option.default;
+            } else if (option.required) {
+                throw new Error(`[ ZERO ] 必需的参数缺失: ${key}`);
+            }
+        }
+    });
+
+    return result;
+}
+module.exports = {
+    parseMetadata,
+    parseArgument,
+}

package/src/epic/momo.fn.cx.js

@@ -0,0 +1,81 @@
+const fs = require('fs');
+const U = require('underscore');
+const Immutable = require('immutable');
+
+// Import
+const __LOG = require('./momo.fn.log');
+const __EC = require('./momo.v.errorcode');
+
+const isFile = (path, file = true) => {
+    let existing = fs.existsSync(path);
+    if (existing) {
+        const etat = fs.statSync(path);
+        if (file) {
+            return etat.isFile();
+        } else {
+            return etat.isDirectory();
+        }
+    } else {
+        return false;
+    }
+};
+const FUNS = {
+    Function: U.isFunction,
+    String: arg => "string" === typeof arg,
+    JString: arg => {
+        try {
+            JSON.parse(arg);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    },
+    Enum: (arg, expected = []) => {
+        expected = !U.isArray(expected) ? [] : expected;
+        const $expected = Immutable.fromJS(expected);
+        return $expected.contains(arg);
+    },
+    Valid: (arg) => !!arg,
+    File: (arg) => isFile(arg),
+    Directory: (arg) => isFile(arg, false),
+    Exist: (arg) => fs.existsSync(arg),
+    Empty: (arg) => {
+        const etat = fs.statSync(arg);
+        if (etat.isFile()) {
+            return false;
+        }
+        const children = fs.readdirSync(arg);
+        return 0 === children.length;
+    }
+};
+const EFUNS = {
+    Function: __EC.fn10001,
+    String: __EC.fn10001,
+    JString: __EC.fn10001,
+    Valid: __EC.fn10001,
+    Enum: __EC.fn10002,
+    File: __EC.fn10007,
+    Directory: __EC.fn10008,
+    Exist: __EC.fn10009,
+    Empty: __EC.fn10023,
+};
+const _sure = (type) => (arg, config = {}) => {
+    const check = FUNS[type];
+    const message = EFUNS[type](arg, type, config);
+    const checked = !check(arg, config);
+    if (checked) {
+        __LOG.error(message);
+        throw new Error(`错误！${message}`);
+    } else return true;
+};
+module.exports = {
+    cxFunction: _sure('Function'),
+    cxString: _sure('String'),
+    cxJString: _sure('JString'),
+    cxEnum: _sure('Enum'),
+    cxValid: _sure('Valid'),
+    cxFile: _sure('File'),
+    cxExist: _sure('Exist'),
+    cxDirectory: _sure('Directory'),
+    cxEmpty: _sure('Empty')
+};

package/src/epic/momo.fn.dir.js

@@ -0,0 +1,87 @@
+const __FX = require("./momo.fn.fx");
+const fs = require("fs");
+const U = require("underscore");
+const __LOG = require("./momo.fn.log");
+const __V = require("./momo.v.constant");
+const __U = require("./momo.fn.find");
+const __IS = require("./momo.fn.is");
+const __IO = require("./momo.fn.io");
+const dirResolve = (path = "") => {
+    let result = path.trim();
+    if (result.endsWith(__V.FILE_DELIMITER)) {
+        result = result.substring(0, result.length - 1);
+    }
+    return result;
+};
+const dirTree = (pathDir = ".", pathFilterFn) => {
+    // 截取当前运行目录
+    const pathStart = __IO.ioSwitch(pathDir);
+    // 往上查找项目根目录
+    const pathArr = pathStart.split(__V.FILE_DELIMITER);
+    const pathIt = [];
+    while (0 < pathArr.length) {
+        const folder = pathArr.join("/");
+        if ('' !== folder) {
+            if (U.isFunction(pathFilterFn)) {
+                if (pathFilterFn(folder)) {
+                    pathIt.push(folder);
+                }
+            } else {
+                pathIt.push(folder);
+            }
+        }
+        pathArr.pop();
+    }
+    return pathIt;
+}
+const dirParent = (path, includeCurrent = false) => {
+    let result = [];
+    if (includeCurrent) {
+        result.push(path);
+    }
+    __FX.fxContinue(fs.existsSync(path), () => {
+        let parent = dirResolve(path);
+        parent = parent.substring(0, parent.lastIndexOf(__V.FILE_DELIMITER));
+        result.push(parent);
+        result = result.concat(dirParent(parent, false));
+    });
+    return result;
+};
+
+const dirChildren = (path, includeCurrent = true) => {
+    let result = [];
+    if (includeCurrent) {
+        result.push(path);
+    }
+    __FX.fxContinue(fs.existsSync(path), () => {
+        const folders = fs.readdirSync(path);
+        const directory = dirResolve(path) + __V.FILE_DELIMITER;
+        folders.forEach(item => __FX.fxContinue(!item.startsWith('.'), () => {
+            const absolute = directory + item;
+            if (__IS.isDirectory(absolute)) {
+                result.push(absolute);
+                result = result.concat(dirChildren(absolute, false));
+            }
+        }));
+    });
+    return result;
+};
+
+const dirCreate = (path = "") => {
+    // TODO: Path专用
+    const folderInfo = __U.findTrace(path);
+    // 查找第一个存在的目录
+    const lefts = folderInfo.filter(item => !__IS.isExist(item)).sort((left, right) => left.length - right.length);
+    lefts.filter(item => '' !== item).forEach(left => {
+        __LOG.info("创建目录：" + left.yellow);
+        fs.mkdirSync(left);
+    });
+    return true;
+};
+module.exports = {
+    dirCreate,
+    dirChildren,
+    dirParent,
+    dirResolve,
+    dirTree,
+}

package/src/epic/momo.fn.element.js

@@ -0,0 +1,52 @@
+const __FX = require('./momo.fn.fx');
+/**
+ * ## `Ec.elementZip`
+ *
+ * （后期将升级或被废弃）
+ *
+ * @memberOf module:_epic
+ * @deprecated
+ * @param {Array} source 原数组
+ * @param {Array} target 目标数组
+ * @param {Boolean} merged 执行合并的模式，覆盖和追加
+ * @returns {Object} 返回最终的数据信息
+ */
+const elementZip = (source = [], target = [], merged = false) => {
+    const length = Math.min(source.length, target.length);
+    const dataItem = {};
+    for (let idx = 0; idx < length; idx++) {
+        if (merged) {
+            dataItem[source[idx]] = target[idx];
+        } else {
+            dataItem['source'] = source[idx];
+            dataItem['target'] = target[idx];
+        }
+
+    }
+    return dataItem;
+};
+/**
+ * ## `Ec.elementUnique`
+ *
+ * ### 1. 基本介绍
+ *
+ * 在输入数组中查找`field = value`的唯一元素对象。
+ *
+ * @memberOf module:_epic
+ * @param {Array} array 输入数组信息
+ * @param {String} field 查找的字段信息
+ * @param value 执行过滤和匹配的`field = value`的值
+ * @returns {*} 返回查找的唯一元素
+ */
+const elementUnique = (array = [], field, value) => {
+    if (field && value) {
+        const filtered = array.filter(item => value === item[field]);
+        __FX.fxError(1 < filtered.length, 10021, field, value);
+        return filtered[0];
+    }
+};
+const exported = {
+    elementZip,
+    elementUnique
+};
+module.exports = exported;