tfose5-xlsx 3.2.2 → 3.2.4

package/README.md

@@ -1 +1 @@
-# ![Version](https://img.shields.io/badge/version-3.2.2-green.svg)
+# ![Version](https://img.shields.io/badge/version-3.2.4-green.svg)

package/dist/cell-parser-base.d.ts

@@ -0,0 +1,9 @@
+import { XlsxCellParserParseOption } from './cell-parser-parse-option';
+import { EnumItem } from './enum-item';
+import { IXlsxParser } from './i-parser';
+export declare abstract class XlsxCellParserBase<T> implements IXlsxParser<XlsxCellParserParseOption, T> {
+    abstract parse(opt: XlsxCellParserParseOption): T;
+    protected getEnumFieldIndexDoc(enumName: string, opt: XlsxCellParserParseOption, field?: keyof EnumItem): {
+        [fieldValue: string]: number;
+    };
+}

package/dist/cell-parser-base.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XlsxCellParserBase = void 0;
+class XlsxCellParserBase {
+    getEnumFieldIndexDoc(enumName, opt, field = 'text') {
+        var _a, _b, _c;
+        var _d;
+        (_a = opt.allEnumIndexDoc) !== null && _a !== void 0 ? _a : (opt.allEnumIndexDoc = {});
+        const allIndexDoc = (_b = (_d = opt.allEnumIndexDoc)[enumName]) !== null && _b !== void 0 ? _b : (_d[enumName] = {});
+        if (!allIndexDoc[field]) {
+            allIndexDoc[field] = {};
+            const allItem = (_c = opt.allEnumItem[enumName]) !== null && _c !== void 0 ? _c : new Map();
+            allItem.forEach(r => {
+                allIndexDoc[field][r[field]] = r.value;
+            });
+        }
+        return allIndexDoc[field];
+    }
+}
+exports.XlsxCellParserBase = XlsxCellParserBase;

package/dist/cell-parser-parse-option.d.ts

@@ -0,0 +1,16 @@
+import { EnumItem } from './enum-item';
+export type XlsxCellParserParseOption = {
+    ext: string;
+    field: string;
+    value: any;
+    allEnumItem: {
+        [enumName: string]: Map<number, EnumItem>;
+    };
+    allEnumIndexDoc?: {
+        [enumName: string]: {
+            [field: string]: {
+                [fieldValue: string]: number;
+            };
+        };
+    };
+};

package/dist/cell-parser-parse-option.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cell-to-array-parser.d.ts

@@ -0,0 +1,8 @@
+import { XlsxCellParserParseOption } from './cell-parser-parse-option';
+import { XlsxEnumSheetParser } from './enum-sheet-parser';
+import { IXlsxParser } from './i-parser';
+export declare class XlsxCellToArrayParser implements IXlsxParser<XlsxCellParserParseOption, unknown[]> {
+    private m_EnumSheetParser;
+    constructor(m_EnumSheetParser: XlsxEnumSheetParser);
+    parse(opt: XlsxCellParserParseOption): unknown[];
+}

package/dist/cell-to-array-parser.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XlsxCellToArrayParser = void 0;
+class XlsxCellToArrayParser {
+    constructor(m_EnumSheetParser) {
+        this.m_EnumSheetParser = m_EnumSheetParser;
+    }
+    parse(opt) {
+        var _a;
+        if (typeof opt.value != 'string')
+            return [];
+        const [type, ...others] = opt.ext.split('.');
+        const lines = opt.value.split(((_a = others[0]) === null || _a === void 0 ? void 0 : _a.startsWith('\\')) ? new RegExp(others.shift(), 'g') : /\r\n|\n|\r/g);
+        const res = [];
+        const otherExt = others.join('.');
+        for (const r of lines) {
+            res.push(this.m_EnumSheetParser.getCellParser(type).parse(Object.assign(Object.assign({}, opt), { ext: otherExt, value: r })));
+        }
+        return res;
+    }
+}
+exports.XlsxCellToArrayParser = XlsxCellToArrayParser;

package/dist/cell-to-bool-parser.d.ts

@@ -0,0 +1,5 @@
+import { XlsxCellParserParseOption } from './cell-parser-parse-option';
+import { IXlsxParser } from './i-parser';
+export declare class XlsxCellToBoolParser implements IXlsxParser<XlsxCellParserParseOption, boolean> {
+    parse(opt: XlsxCellParserParseOption): boolean;
+}

package/dist/cell-to-bool-parser.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XlsxCellToBoolParser = void 0;
+class XlsxCellToBoolParser {
+    parse(opt) {
+        if (typeof opt.value == 'boolean')
+            return opt.value;
+        if (typeof opt.value == 'string')
+            return opt.value.toLocaleLowerCase() == 'true';
+        return !!opt.value;
+    }
+}
+exports.XlsxCellToBoolParser = XlsxCellToBoolParser;

package/dist/cell-to-enum-parser.d.ts

@@ -0,0 +1,5 @@
+import { XlsxCellParserBase } from './cell-parser-base';
+import { XlsxCellParserParseOption } from './cell-parser-parse-option';
+export declare class XlsxCellToEnumParser extends XlsxCellParserBase<number> {
+    parse(opt: XlsxCellParserParseOption): number;
+}

package/dist/cell-to-enum-parser.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XlsxCellToEnumParser = void 0;
+const tfose5_error_1 = require("tfose5-error");
+const cell_parser_base_1 = require("./cell-parser-base");
+class XlsxCellToEnumParser extends cell_parser_base_1.XlsxCellParserBase {
+    parse(opt) {
+        const [_, enumName, field] = opt.ext.split('.');
+        const indexDoc = this.getEnumFieldIndexDoc(enumName, opt, field);
+        const no = indexDoc[opt.value];
+        if (!no)
+            throw new tfose5_error_1.CustomError(tfose5_error_1.ErrorCode.warning, `${XlsxCellToEnumParser.name}.parse: 无效${enumName}[${opt.value}]`);
+        return no;
+    }
+}
+exports.XlsxCellToEnumParser = XlsxCellToEnumParser;

package/dist/cell-to-json-parser.d.ts

@@ -0,0 +1,5 @@
+import { XlsxCellParserParseOption } from './cell-parser-parse-option';
+import { IXlsxParser } from './i-parser';
+export declare class XlsxCellToJsonParser implements IXlsxParser<XlsxCellParserParseOption, unknown> {
+    parse(opt: XlsxCellParserParseOption): any;
+}

package/dist/cell-to-json-parser.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XlsxCellToJsonParser = void 0;
+class XlsxCellToJsonParser {
+    parse(opt) {
+        return typeof opt.value == 'string' ? JSON.parse(opt.value) : opt.value;
+    }
+}
+exports.XlsxCellToJsonParser = XlsxCellToJsonParser;

package/dist/cell-to-number-parser.d.ts

@@ -0,0 +1,5 @@
+import { XlsxCellParserParseOption } from './cell-parser-parse-option';
+import { IXlsxParser } from './i-parser';
+export declare class XlsxCellToNumberParser implements IXlsxParser<XlsxCellParserParseOption, number> {
+    parse(opt: XlsxCellParserParseOption): number;
+}

package/dist/cell-to-number-parser.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XlsxCellToNumberParser = void 0;
+class XlsxCellToNumberParser {
+    parse(opt) {
+        return Number(opt.value);
+    }
+}
+exports.XlsxCellToNumberParser = XlsxCellToNumberParser;

package/dist/cell-to-rewards-parser.d.ts

@@ -0,0 +1,11 @@
+import { XlsxCellParserBase } from './cell-parser-base';
+import { XlsxCellParserParseOption } from './cell-parser-parse-option';
+import { Value } from './value';
+type Reward = Value & {
+    weight?: number;
+};
+export declare class XlsxCellToRewardsParser extends XlsxCellParserBase<Reward[][]> {
+    static reg: RegExp;
+    parse(opt: XlsxCellParserParseOption): Reward[][];
+}
+export {};

package/dist/cell-to-rewards-parser.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XlsxCellToRewardsParser = void 0;
+const tfose5_error_1 = require("tfose5-error");
+const cell_parser_base_1 = require("./cell-parser-base");
+class XlsxCellToRewardsParser extends cell_parser_base_1.XlsxCellParserBase {
+    parse(opt) {
+        if (typeof opt.value != 'string')
+            return [];
+        const lines = opt.value.split(/\r\n|\n|\r/g);
+        const res = [[]];
+        const valueTypeTextOfValue = this.getEnumFieldIndexDoc('ValueTypeData', opt);
+        for (const r of lines) {
+            const match = r.match(XlsxCellToRewardsParser.reg);
+            if (!match) {
+                if (res[res.length - 1].length) {
+                    res.push([]);
+                    continue;
+                }
+                throw new tfose5_error_1.CustomError(tfose5_error_1.ErrorCode.warning, `${this.constructor.name}.parse: 无效奖励格式[${r}]`);
+            }
+            const valueType = valueTypeTextOfValue[match[1]];
+            if (!valueType)
+                throw new tfose5_error_1.CustomError(tfose5_error_1.ErrorCode.warning, `${this.constructor.name}.parse: 无效奖励名[${r}]`);
+            const count = Number(match[2]);
+            if (isNaN(count))
+                throw new tfose5_error_1.CustomError(tfose5_error_1.ErrorCode.warning, `${this.constructor.name}.parse: 无效奖励数量[${r}]`);
+            res[res.length - 1].push({
+                count,
+                valueType,
+                weight: match[3] && Number(match[3].slice(1)) || 0,
+            });
+        }
+        return res;
+    }
+}
+exports.XlsxCellToRewardsParser = XlsxCellToRewardsParser;
+XlsxCellToRewardsParser.reg = /^([^*]+)\*(-?[\deE+\.]+)(\*?(\d+))?$/;

package/dist/cell-to-string-parser.d.ts

@@ -0,0 +1,5 @@
+import { XlsxCellParserParseOption } from './cell-parser-parse-option';
+import { IXlsxParser } from './i-parser';
+export declare class XlsxCellToStringParser implements IXlsxParser<XlsxCellParserParseOption, string> {
+    parse(opt: XlsxCellParserParseOption): any;
+}

package/dist/cell-to-string-parser.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XlsxCellToStringParser = void 0;
+class XlsxCellToStringParser {
+    parse(opt) {
+        return (typeof opt.value == 'string' ? opt.value : opt.value.toString()).trim();
+    }
+}
+exports.XlsxCellToStringParser = XlsxCellToStringParser;

package/dist/cell-to-unix-parser.d.ts

@@ -0,0 +1,5 @@
+import { XlsxCellParserParseOption } from './cell-parser-parse-option';
+import { IXlsxParser } from './i-parser';
+export declare class XlsxCellToUnixParser implements IXlsxParser<XlsxCellParserParseOption, number> {
+    parse(opt: XlsxCellParserParseOption): number;
+}

package/dist/cell-to-unix-parser.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XlsxCellToUnixParser = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+class XlsxCellToUnixParser {
+    parse(opt) {
+        try {
+            return (0, dayjs_1.default)(opt.value.toString()).unix();
+        }
+        catch (_a) {
+            return 0;
+        }
+    }
+}
+exports.XlsxCellToUnixParser = XlsxCellToUnixParser;

package/dist/cell-to-value-conditions-parser.d.ts

@@ -0,0 +1,11 @@
+import { XlsxCellParserBase } from './cell-parser-base';
+import { XlsxCellParserParseOption } from './cell-parser-parse-option';
+import { Value } from './value';
+type ValueCondition = Value & {
+    op: string;
+};
+export declare class XlsxCellToValueConditionsParser extends XlsxCellParserBase<ValueCondition[][]> {
+    static reg: RegExp;
+    parse(opt: XlsxCellParserParseOption): ValueCondition[][];
+}
+export {};

package/dist/cell-to-value-conditions-parser.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XlsxCellToValueConditionsParser = void 0;
+const tfose5_error_1 = require("tfose5-error");
+const cell_parser_base_1 = require("./cell-parser-base");
+class XlsxCellToValueConditionsParser extends cell_parser_base_1.XlsxCellParserBase {
+    parse(opt) {
+        if (typeof opt.value != 'string')
+            return [];
+        const lines = opt.value.split(/\r\n|\n|\r/g);
+        let res = [[]];
+        const valueTypeTextOfValue = this.getEnumFieldIndexDoc('ValueTypeData', opt);
+        for (const r of lines) {
+            const match = r.match(XlsxCellToValueConditionsParser.reg);
+            if (!match) {
+                if (res[res.length - 1].length) {
+                    res.push([]);
+                    continue;
+                }
+                throw new tfose5_error_1.CustomError(tfose5_error_1.ErrorCode.warning, `${this.constructor.name}.parse: 无效数值条件格式[${r}]`);
+            }
+            const valueType = valueTypeTextOfValue[match[1]];
+            if (!valueType)
+                throw new tfose5_error_1.CustomError(tfose5_error_1.ErrorCode.warning, `${this.constructor.name}.parse: 无效数值条件名[${r}]`);
+            const count = Number(match[4]);
+            if (isNaN(count))
+                throw new tfose5_error_1.CustomError(tfose5_error_1.ErrorCode.warning, `${this.constructor.name}.parse: 无效数值条件数量[${r}]`);
+            res[res.length - 1].push({
+                count,
+                op: match[2] && match[2] + match[3] || match[3],
+                valueType,
+            });
+        }
+        return res;
+    }
+}
+exports.XlsxCellToValueConditionsParser = XlsxCellToValueConditionsParser;
+XlsxCellToValueConditionsParser.reg = /^([\u4e00-\u9fff]+)(%|&|now-day|now-diff|own)*([=><]+)(-?\d+([\.eE+\d]+)?)$/;

package/dist/cell-to-value-parser.d.ts

@@ -0,0 +1,10 @@
+import { XlsxCellParserBase } from './cell-parser-base';
+import { XlsxCellParserParseOption } from './cell-parser-parse-option';
+import { Value } from './value';
+export declare class XlsxCellToValueParser extends XlsxCellParserBase<Value> {
+    static reg: RegExp;
+    parse(opt: XlsxCellParserParseOption): {
+        count: number;
+        valueType: number;
+    };
+}

package/dist/cell-to-value-parser.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XlsxCellToValueParser = void 0;
+const tfose5_error_1 = require("tfose5-error");
+const cell_parser_base_1 = require("./cell-parser-base");
+class XlsxCellToValueParser extends cell_parser_base_1.XlsxCellParserBase {
+    parse(opt) {
+        const match = opt.value.toString().match(XlsxCellToValueParser.reg);
+        if (!match)
+            throw new tfose5_error_1.CustomError(tfose5_error_1.ErrorCode.warning, `${this.constructor.name}.parse: 无效数值格式[${opt.value}]`);
+        const valueTypeTextOfValue = this.getEnumFieldIndexDoc('ValueTypeData', opt);
+        const valueType = valueTypeTextOfValue[match[1]];
+        if (!valueType)
+            throw new tfose5_error_1.CustomError(tfose5_error_1.ErrorCode.warning, `${this.constructor.name}.parse: 无效数值名[${opt.value}]`);
+        const count = Number(match[2]);
+        if (isNaN(count))
+            throw new tfose5_error_1.CustomError(tfose5_error_1.ErrorCode.warning, `${this.constructor.name}.parse: 无效数值数量[${opt.value}]`);
+        return {
+            count,
+            valueType,
+        };
+    }
+}
+exports.XlsxCellToValueParser = XlsxCellToValueParser;
+XlsxCellToValueParser.reg = /^(.+)\*(-?[\.eE+\d]+)$/;

package/dist/enum-item.d.ts

@@ -0,0 +1,6 @@
+export type EnumItem = {
+    value: number;
+} & Partial<{
+    key: string;
+    text: string;
+}>;

package/dist/enum-item.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/enum-sheet-parser-base.d.ts

@@ -0,0 +1,6 @@
+import { EnumItem } from './enum-item';
+import { XlsxEnumSheetParserParseOption } from './enum-sheet-parser-parse-option';
+import { IXlsxParser } from './i-parser';
+export declare abstract class XlsxEnumSheetParserBase implements IXlsxParser<XlsxEnumSheetParserParseOption, EnumItem[]> {
+    abstract parse(input: XlsxEnumSheetParserParseOption): EnumItem[];
+}

package/dist/enum-sheet-parser-base.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XlsxEnumSheetParserBase = void 0;
+class XlsxEnumSheetParserBase {
+}
+exports.XlsxEnumSheetParserBase = XlsxEnumSheetParserBase;

package/dist/enum-sheet-parser-parse-option.d.ts

@@ -0,0 +1,7 @@
+import { EnumItem } from './enum-item';
+import { XlsxWorkBookParserParseResult } from './work-book-parser-parse-result';
+export type XlsxEnumSheetParserParseOption = XlsxWorkBookParserParseResult & {
+    allEnumItem: {
+        [enumName: string]: Map<number, EnumItem>;
+    };
+};

package/dist/enum-sheet-parser-parse-option.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/enum-sheet-parser.d.ts

@@ -0,0 +1,12 @@
+import { XlsxCellParserParseOption } from './cell-parser-parse-option';
+import { XlsxEnumSheetParserBase } from './enum-sheet-parser-base';
+import { XlsxEnumSheetParserParseOption } from './enum-sheet-parser-parse-option';
+import { IXlsxParser } from './i-parser';
+export declare class XlsxEnumSheetParser extends XlsxEnumSheetParserBase {
+    private m_AllCellParser?;
+    protected get allCellParser(): {
+        [type: string]: IXlsxParser<XlsxCellParserParseOption, unknown>;
+    };
+    getCellParser(type: string): IXlsxParser<XlsxCellParserParseOption, unknown>;
+    parse(opt: XlsxEnumSheetParserParseOption): any;
+}

package/dist/enum-sheet-parser.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XlsxEnumSheetParser = void 0;
+const tfose5_error_1 = require("tfose5-error");
+const cell_to_array_parser_1 = require("./cell-to-array-parser");
+const cell_to_bool_parser_1 = require("./cell-to-bool-parser");
+const cell_to_enum_parser_1 = require("./cell-to-enum-parser");
+const cell_to_json_parser_1 = require("./cell-to-json-parser");
+const cell_to_number_parser_1 = require("./cell-to-number-parser");
+const cell_to_rewards_parser_1 = require("./cell-to-rewards-parser");
+const cell_to_string_parser_1 = require("./cell-to-string-parser");
+const cell_to_unix_parser_1 = require("./cell-to-unix-parser");
+const cell_to_value_parser_1 = require("./cell-to-value-parser");
+const cell_to_value_conditions_parser_1 = require("./cell-to-value-conditions-parser");
+const enum_sheet_parser_base_1 = require("./enum-sheet-parser-base");
+const numReg = /^\d+$/;
+class XlsxEnumSheetParser extends enum_sheet_parser_base_1.XlsxEnumSheetParserBase {
+    get allCellParser() {
+        var _a;
+        (_a = this.m_AllCellParser) !== null && _a !== void 0 ? _a : (this.m_AllCellParser = {
+            array: new cell_to_array_parser_1.XlsxCellToArrayParser(this),
+            bool: new cell_to_bool_parser_1.XlsxCellToBoolParser(),
+            enum: new cell_to_enum_parser_1.XlsxCellToEnumParser(),
+            json: new cell_to_json_parser_1.XlsxCellToJsonParser(),
+            number: new cell_to_number_parser_1.XlsxCellToNumberParser(),
+            rewards: new cell_to_rewards_parser_1.XlsxCellToRewardsParser(),
+            string: new cell_to_string_parser_1.XlsxCellToStringParser(),
+            unix: new cell_to_unix_parser_1.XlsxCellToUnixParser(),
+            value: new cell_to_value_parser_1.XlsxCellToValueParser(),
+            valueConditions: new cell_to_value_conditions_parser_1.XlsxCellToValueConditionsParser(),
+        });
+        return this.m_AllCellParser;
+    }
+    getCellParser(type) {
+        const parser = this.allCellParser[type];
+        if (!parser)
+            throw new tfose5_error_1.CustomError(tfose5_error_1.ErrorCode.warning, `${this.constructor.name}.getCellParser: 无效解析器[${type}]`);
+        return parser;
+    }
+    parse(opt) {
+        var _a, _b, _c, _d;
+        const allTable = {};
+        for (const r of opt.sheets) {
+            const rows = [];
+            const tempRows = [];
+            for (let i = 1; i < r.rows.length; i++) {
+                let row = {};
+                let tempRow = {};
+                const sheetRow = r.rows[i];
+                let isFirstField = true;
+                for (const k in sheetRow) {
+                    const [field, type, ext] = k.split(':');
+                    if (!type)
+                        continue;
+                    let fieldValue;
+                    if (type == '#') {
+                        let [associateTable, associateField] = ext.split('.');
+                        fieldValue = allTable[associateTable];
+                        if (!fieldValue)
+                            continue;
+                        associateField !== null && associateField !== void 0 ? associateField : (associateField = associateTable);
+                        let cellValue = sheetRow[k];
+                        for (const ck in sheetRow) {
+                            if (ck.split(':')[0] == associateField) {
+                                cellValue = sheetRow[ck];
+                                break;
+                            }
+                        }
+                        if (cellValue != undefined) {
+                            fieldValue = fieldValue.filter(cr => {
+                                return cr[associateField] == cellValue;
+                            }).map(cr => {
+                                cr = structuredClone(cr);
+                                delete cr.value;
+                                delete cr[associateField];
+                                return cr;
+                            });
+                        }
+                    }
+                    else {
+                        const parser = this.allCellParser[type];
+                        if (!parser)
+                            continue;
+                        try {
+                            fieldValue = parser.parse({
+                                allEnumItem: opt.allEnumItem,
+                                ext,
+                                field,
+                                value: sheetRow[k],
+                            });
+                        }
+                        catch (ex) {
+                            throw new tfose5_error_1.CustomError(tfose5_error_1.ErrorCode.warning, JSON.stringify({
+                                field: k,
+                                row: i + 2,
+                                sheet: r.name,
+                                text: ex.data,
+                            }));
+                        }
+                    }
+                    if (isFirstField) {
+                        const rowIndex = rows.findIndex(cr => cr[field] == fieldValue);
+                        if (rowIndex == -1) {
+                            rows.push(row);
+                            tempRows.push(tempRow);
+                        }
+                        else {
+                            row = rows[rowIndex];
+                            tempRow = tempRows[rowIndex];
+                        }
+                        isFirstField = false;
+                    }
+                    const fieldParts = field.split('.');
+                    if (fieldParts.length > 1) {
+                        let obj = row;
+                        while (fieldParts.length) {
+                            let name = fieldParts.shift();
+                            if (name in tempRow && typeof tempRow[name] != 'object')
+                                name = tempRow[name];
+                            if (fieldParts.length) {
+                                (_a = obj[name]) !== null && _a !== void 0 ? _a : (obj[name] = numReg.test(fieldParts[0]) ? [] : {});
+                                obj = obj[name];
+                            }
+                            else if ((_b = name.startsWith) === null || _b === void 0 ? void 0 : _b.call(name, '[')) {
+                                tempRow[name.substring(1, name.length - 1)] = fieldValue;
+                            }
+                            else {
+                                obj[name] = fieldValue;
+                            }
+                        }
+                    }
+                    else if (!field.startsWith('_')) {
+                        (_c = row[field]) !== null && _c !== void 0 ? _c : (row[field] = fieldValue);
+                    }
+                }
+            }
+            allTable[r.name] = rows;
+        }
+        return (_d = allTable[opt.enumName]) !== null && _d !== void 0 ? _d : [];
+    }
+}
+exports.XlsxEnumSheetParser = XlsxEnumSheetParser;

package/dist/file-parser-base.d.ts

@@ -0,0 +1,5 @@
+import { XlsxFileParserParseResult } from './file-parser-parse-result';
+import { IXlsxParser } from './i-parser';
+export declare abstract class XlsxFileParserBase implements IXlsxParser<string, XlsxFileParserParseResult> {
+    abstract parse(path: string): XlsxFileParserParseResult;
+}

package/dist/file-parser-base.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XlsxFileParserBase = void 0;
+class XlsxFileParserBase {
+}
+exports.XlsxFileParserBase = XlsxFileParserBase;

package/dist/file-parser-parse-result.d.ts

@@ -0,0 +1,7 @@
+export type XlsxFileParserParseResult = {
+    enumName: string;
+    sheets: {
+        name: string;
+        rows: object[];
+    }[];
+};

package/dist/file-parser-parse-result.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/file-parser.d.ts

@@ -0,0 +1,10 @@
+import { XlsxFileParserBase } from './file-parser-base';
+export declare class XlsxFileParser extends XlsxFileParserBase {
+    parse(path: string): {
+        sheets: {
+            name: string;
+            rows: object[];
+        }[];
+        enumName: string;
+    };
+}

package/dist/file-parser.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XlsxFileParser = void 0;
+const xlsx_1 = require("xlsx");
+const file_parser_base_1 = require("./file-parser-base");
+class XlsxFileParser extends file_parser_base_1.XlsxFileParserBase {
+    parse(path) {
+        const wb = (0, xlsx_1.readFile)(path);
+        return {
+            sheets: wb.SheetNames.filter(r => {
+                return !r.includes('_');
+            }).map(r => {
+                return {
+                    name: r,
+                    rows: xlsx_1.utils.sheet_to_json(wb.Sheets[r]),
+                };
+            }).reverse(),
+            enumName: wb.SheetNames[0],
+        };
+    }
+}
+exports.XlsxFileParser = XlsxFileParser;

package/dist/i-parser.d.ts

@@ -0,0 +1,3 @@
+export interface IXlsxParser<TIn, TOut> {
+    parse(input: TIn): TOut;
+}

package/dist/i-parser.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/mock.d.ts

@@ -0,0 +1,12 @@
+export declare const mockAny: any;
+export declare class Mock<T> {
+    private m_Target;
+    private m_CurrentKey;
+    private m_Records;
+    private m_Actutal;
+    get actual(): T;
+    private m_Expected;
+    get expected(): T;
+    constructor(m_Target?: {});
+    expectReturn(action: (target: T) => any, returnValue: any): void;
+}

package/dist/mock.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mock = exports.mockAny = void 0;
+const assert_1 = require("assert");
+class Record {
+    constructor() {
+        this.args = [];
+        this.returnValues = [];
+    }
+}
+exports.mockAny = new Object();
+class Mock {
+    get actual() {
+        if (!this.m_Actutal) {
+            this.m_Actutal = new Proxy(this.m_Target, {
+                get: (target, key) => {
+                    if (key in target)
+                        return target[key];
+                    if (key == 'then' || key == 'catch')
+                        return this.m_Actutal;
+                    return (...args) => {
+                        const record = this.m_Records[key];
+                        if (!(record && record.args.length))
+                            throw new Error(`${key}未被调用`);
+                        const recordArgs = record.args.shift();
+                        (0, assert_1.deepStrictEqual)(args.map((r, i) => {
+                            return recordArgs[i] == exports.mockAny ? exports.mockAny : r;
+                        }), recordArgs);
+                        return record.returnValues.shift();
+                    };
+                }
+            });
+        }
+        return this.m_Actutal;
+    }
+    get expected() {
+        return this.m_Expected;
+    }
+    constructor(m_Target = {}) {
+        this.m_Target = m_Target;
+        this.m_Records = {};
+        this.m_Actutal = null;
+        this.m_Expected = new Proxy({}, {
+            get: (_, key) => {
+                this.m_CurrentKey = key;
+                if (!this.m_Records[key])
+                    this.m_Records[key] = new Record();
+                return (...args) => {
+                    this.m_Records[key].args.push(args);
+                };
+            }
+        });
+    }
+    expectReturn(action, returnValue) {
+        action(this.expected);
+        this.m_Records[this.m_CurrentKey].returnValues.push(returnValue);
+    }
+}
+exports.Mock = Mock;

package/dist/parse-to-enum-json.js

@@ -20,21 +20,22 @@ const to_json_converter_1 = require("./to-json-converter");
 const to_number_converter_1 = require("./to-number-converter");
 const to_rewards_converter_1 = require("./to-rewards-converter");
 const to_unix_converter_1 = require("./to-unix-converter");
-const to_value_converter_1 = require("./to-value-converter");
 const to_value_conditions_converter_1 = require("./to-value-conditions-converter");
+const to_value_converter_1 = require("./to-value-converter");
 const allEnumTextNo = {};
 let converterFactory;
 function parseXlsxToEnumJson(fsFactory_1, dstDirPath_1, srcDirPath_1) {
     return __awaiter(this, arguments, void 0, function* (fsFactory, dstDirPath, srcDirPath, topEnums = ['ValueEnum']) {
         var _a;
-        converterFactory = new converter_factory_1.ConverterFactory(new to_enum_no_converter_1.ToEnumNoConverter(allEnumTextNo), {
+        const toEnumNoConverter = new to_enum_no_converter_1.ToEnumNoConverter(allEnumTextNo);
+        converterFactory = new converter_factory_1.ConverterFactory(toEnumNoConverter, {
             bool: new to_bool_converter_1.ToBoolConverter(),
-            conditions: new to_value_conditions_converter_1.ToValueConditionsConverter(allEnumTextNo, topEnums[topEnums.length - 1]),
+            conditions: new to_value_conditions_converter_1.ToValueConditionsConverter(toEnumNoConverter, topEnums[topEnums.length - 1]),
             json: new to_json_converter_1.ToJsonConverter(),
             number: new to_number_converter_1.ToNumberConverter(),
-            rewards: new to_rewards_converter_1.ToRewardsConverter(allEnumTextNo, topEnums[topEnums.length - 1]),
+            rewards: new to_rewards_converter_1.ToRewardsConverter(toEnumNoConverter, topEnums[topEnums.length - 1]),
             unit: new to_unix_converter_1.ToUnixConverter(),
-            value: new to_value_converter_1.ToValueConverter(allEnumTextNo, topEnums[topEnums.length - 1]),
+            value: new to_value_converter_1.ToValueConverter(toEnumNoConverter, topEnums[topEnums.length - 1]),
         });
         const filePaths = [];
         yield fsFactory.build(tfose5_fs_1.FsScanBase).scan({
@@ -56,12 +57,15 @@ function parseXlsxToEnumJson(fsFactory_1, dstDirPath_1, srcDirPath_1) {
                 continue;
             const sheets = (0, xlsx_1.readFile)(r).Sheets;
             const enumName = (0, path_1.basename)(r).replace('.xlsx', '');
+            console.log(`xlsx: ${enumName}`);
             const allOtherSheetRows = {};
             for (const k in sheets) {
                 if (k == enumName)
                     continue;
+                console.log(`  sheet: ${k}`);
                 allOtherSheetRows[k] = parseSheet(sheets[k]);
             }
+            console.log(`  sheet: ${enumName}`);
             const enumItems = parseSheet(sheets[enumName], allOtherSheetRows);
             if ((_a = enumItems[0]) === null || _a === void 0 ? void 0 : _a.text) {
                 allEnumTextNo[enumName] = enumItems.reduce((memo, r) => {
@@ -96,7 +100,7 @@ function parseSheet(sheet, allOtherSheetRows) {
                 });
             }
             else if (type == 'array') {
-                fieldValue = cr[1].split('\r\n').map(sr => {
+                fieldValue = cr[1].toString().split(/\r\n|\n|\r/g).map(sr => {
                     return converterFactory.build(ext).convert(sr, ext);
                 });
             }

package/dist/parser-factory.d.ts

@@ -0,0 +1,7 @@
+import { XlsxEnumSheetParserBase } from './enum-sheet-parser-base';
+import { XlsxWorkBookParserBase } from './work-book-parser-base';
+export declare class XlsxParserFactory {
+    static ctor: string;
+    build(typer: typeof XlsxEnumSheetParserBase): XlsxEnumSheetParserBase;
+    build(typer: typeof XlsxWorkBookParserBase): XlsxWorkBookParserBase;
+}

package/dist/parser-factory.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XlsxParserFactory = void 0;
+const enum_sheet_parser_1 = require("./enum-sheet-parser");
+const enum_sheet_parser_base_1 = require("./enum-sheet-parser-base");
+const work_book_parser_1 = require("./work-book-parser");
+const work_book_parser_base_1 = require("./work-book-parser-base");
+class XlsxParserFactory {
+    build(typer) {
+        return typer == enum_sheet_parser_base_1.XlsxEnumSheetParserBase && new enum_sheet_parser_1.XlsxEnumSheetParser()
+            || typer == work_book_parser_base_1.XlsxWorkBookParserBase && new work_book_parser_1.XlsxWorkBookParser();
+    }
+}
+exports.XlsxParserFactory = XlsxParserFactory;
+XlsxParserFactory.ctor = 'XlsxParserFactory';

package/dist/to-rewards-converter.d.ts

@@ -1,13 +1,12 @@
-import { AllEnumTextNo } from './all-enum-text-no';
 import { IConverter } from './i-converter';
 import { Value } from './value';
 type Reward = Value & {
     weight: number;
 };
 export declare class ToRewardsConverter implements IConverter {
-    private m_AllEnumTextNo;
+    private m_ToEnumNoConverter;
     private m_EnumName;
-    constructor(m_AllEnumTextNo: AllEnumTextNo, m_EnumName: string);
+    constructor(m_ToEnumNoConverter: IConverter, m_EnumName: string);
     convert(s: string): Reward[][];
 }
 export {};

package/dist/to-rewards-converter.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToRewardsConverter = void 0;
 const reg = /^([^*]+)\*(-?[\deE+\.]+)(\*?(\d+))?$/;
 class ToRewardsConverter {
-    constructor(m_AllEnumTextNo, m_EnumName) {
-        this.m_AllEnumTextNo = m_AllEnumTextNo;
+    constructor(m_ToEnumNoConverter, m_EnumName) {
+        this.m_ToEnumNoConverter = m_ToEnumNoConverter;
         this.m_EnumName = m_EnumName;
     }
     convert(s) {
-        return s.split('\r\n').reduce((memo, r) => {
+        return s.split(/\r\n|\n|\r/g).reduce((memo, r) => {
             const match = r.match(reg);
             if (!match) {
                 if (memo[memo.length - 1].length) {
@@ -17,15 +17,12 @@ class ToRewardsConverter {
                 }
                 throw new Error(`${this.constructor.name}: 无效格式[${r}]`);
             }
-            const valueNo = this.m_AllEnumTextNo[this.m_EnumName][match[1]];
-            if (!valueNo)
-                throw new Error(`${this.constructor.name}: 无效数值名[${r}]`);
             const count = Number(match[2]);
             if (isNaN(count))
                 throw new Error(`${this.constructor.name}: 无效数量[${r}]`);
             memo[memo.length - 1].push({
                 count,
-                no: valueNo,
+                no: this.m_ToEnumNoConverter.convert(match[1], this.m_EnumName),
                 weight: match[3] && Number(match[3].slice(1)) || 0,
             });
             return memo;

package/dist/to-value-conditions-converter.d.ts

@@ -1,13 +1,12 @@
-import { AllEnumTextNo } from './all-enum-text-no';
 import { IConverter } from './i-converter';
 import { Value } from './value';
 type ValueCondition = Value & {
     op: string;
 };
 export declare class ToValueConditionsConverter implements IConverter {
-    private m_AllEnumTextNo;
+    private m_ToEnumNoConverter;
     private m_Enum;
-    constructor(m_AllEnumTextNo: AllEnumTextNo, m_Enum: string);
+    constructor(m_ToEnumNoConverter: IConverter, m_Enum: string);
     convert(s: string): ValueCondition[][];
 }
 export {};

package/dist/to-value-conditions-converter.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToValueConditionsConverter = void 0;
 const reg = /^([\u4e00-\u9fff]+)(%|&|now-day|now-diff|own)*([=><]+)(-?\d+([\.eE+\d]+)?)$/;
 class ToValueConditionsConverter {
-    constructor(m_AllEnumTextNo, m_Enum) {
-        this.m_AllEnumTextNo = m_AllEnumTextNo;
+    constructor(m_ToEnumNoConverter, m_Enum) {
+        this.m_ToEnumNoConverter = m_ToEnumNoConverter;
         this.m_Enum = m_Enum;
     }
     convert(s) {
@@ -21,15 +21,12 @@ class ToValueConditionsConverter {
                 }
                 throw new Error(`${this.constructor.name}: 无效数值条件格式[${r}]`);
             }
-            const valueNo = this.m_AllEnumTextNo[this.m_Enum][match[1]];
-            if (!valueNo)
-                throw new Error(`${this.constructor.name}: 无效数值条件名[${r}]`);
             const count = Number(match[4]);
             if (isNaN(count))
                 throw new Error(`${this.constructor.name}: 无效数值条件数量[${r}]`);
             res[res.length - 1].push({
                 count,
-                no: valueNo,
+                no: this.m_ToEnumNoConverter.convert(match[1], this.m_Enum),
                 op: match[2] && match[2] + match[3] || match[3],
             });
         }

package/dist/to-value-converter.d.ts

@@ -1,11 +1,10 @@
-import { AllEnumTextNo } from './all-enum-text-no';
 import { IConverter } from './i-converter';
 export declare class ToValueConverter implements IConverter {
-    private m_AllEnumTextNo;
+    private m_ToEnumNoConverter;
     private m_Enum;
-    constructor(m_AllEnumTextNo: AllEnumTextNo, m_Enum: string);
+    constructor(m_ToEnumNoConverter: IConverter, m_Enum: string);
     convert(s: string): {
         count: number;
-        no: number;
+        no: unknown;
     };
 }

package/dist/to-value-converter.js

@@ -2,15 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToValueConverter = void 0;
 class ToValueConverter {
-    constructor(m_AllEnumTextNo, m_Enum) {
-        this.m_AllEnumTextNo = m_AllEnumTextNo;
+    constructor(m_ToEnumNoConverter, m_Enum) {
+        this.m_ToEnumNoConverter = m_ToEnumNoConverter;
         this.m_Enum = m_Enum;
     }
     convert(s) {
         const [text, count] = s.split('*');
         return {
             count: Number(count),
-            no: this.m_AllEnumTextNo[this.m_Enum][text],
+            no: this.m_ToEnumNoConverter.convert(text, this.m_Enum),
         };
     }
 }

package/dist/work-book-parser-base.d.ts

@@ -0,0 +1,6 @@
+import { WorkBook } from 'xlsx';
+import { XlsxWorkBookParserParseResult } from './work-book-parser-parse-result';
+import { IXlsxParser } from './i-parser';
+export declare abstract class XlsxWorkBookParserBase implements IXlsxParser<WorkBook, XlsxWorkBookParserParseResult> {
+    abstract parse(wb: WorkBook): XlsxWorkBookParserParseResult;
+}

package/dist/work-book-parser-base.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XlsxWorkBookParserBase = void 0;
+class XlsxWorkBookParserBase {
+}
+exports.XlsxWorkBookParserBase = XlsxWorkBookParserBase;

package/dist/work-book-parser-parse-result.d.ts

@@ -0,0 +1,7 @@
+export type XlsxWorkBookParserParseResult = {
+    enumName: string;
+    sheets: {
+        name: string;
+        rows: object[];
+    }[];
+};

package/dist/work-book-parser-parse-result.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/work-book-parser.d.ts

@@ -0,0 +1,11 @@
+import { WorkBook } from 'xlsx';
+import { XlsxWorkBookParserBase } from './work-book-parser-base';
+export declare class XlsxWorkBookParser extends XlsxWorkBookParserBase {
+    parse(wb: WorkBook): {
+        enumName: string;
+        sheets: {
+            name: string;
+            rows: object[];
+        }[];
+    };
+}

package/dist/work-book-parser.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XlsxWorkBookParser = void 0;
+const xlsx_1 = require("xlsx");
+const work_book_parser_base_1 = require("./work-book-parser-base");
+class XlsxWorkBookParser extends work_book_parser_base_1.XlsxWorkBookParserBase {
+    parse(wb) {
+        return {
+            enumName: wb.SheetNames[0],
+            sheets: wb.SheetNames.filter(r => {
+                return !r.includes('_');
+            }).map(r => {
+                return {
+                    name: r,
+                    rows: xlsx_1.utils.sheet_to_json(wb.Sheets[r]),
+                };
+            }).reverse(),
+        };
+    }
+}
+exports.XlsxWorkBookParser = XlsxWorkBookParser;

package/package.json

@@ -24,5 +24,5 @@
         "test": "mocha -t 30s -r ./node_modules/ts-node/register/index.js --exit",
         "version": "ts-node script version"
     },
-    "version": "3.2.2"
+    "version": "3.2.4"
 }