tfose5-xlsx 1.0.0

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): Promise<any>;
+}

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

@@ -0,0 +1,20 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XlsxCellToJsonParser = void 0;
+class XlsxCellToJsonParser {
+    parse(opt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 { XlsxFileParserParseResult } from './file-parser-parse-result';
+export type XlsxEnumSheetParserParseOption = XlsxFileParserParseResult & {
+    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/index.d.ts

@@ -0,0 +1,4 @@
+export * from './enum-sheet-parser-base';
+export * from './file-parser-base';
+export * from './i-parser';
+export * from './parser-factory';