datera 0.1.0

package/dist/filters/validate.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RowValidator = exports.DEFAULT_REASON_COLUMN = exports.DEFAULT_PENDING_SHEET = void 0;
+const registry_1 = require("../normalizers/registry");
+exports.DEFAULT_PENDING_SHEET = "Pendências";
+exports.DEFAULT_REASON_COLUMN = "Motivo";
+class RowValidator {
+    reasonColumn;
+    checks;
+    constructor(rules, reasonColumn = exports.DEFAULT_REASON_COLUMN) {
+        this.reasonColumn = reasonColumn;
+        this.checks = rules.map((rule) => this.buildCheck(rule));
+    }
+    split(rows) {
+        const valid = [];
+        const pending = [];
+        for (const row of rows) {
+            const reasons = this.checks
+                .filter((check) => !this.passes(check, row[check.column]))
+                .map((check) => check.message);
+            if (reasons.length === 0) {
+                valid.push(row);
+                continue;
+            }
+            const withReason = { [this.reasonColumn]: null, ...row };
+            withReason[this.reasonColumn] = Array.from(new Set(reasons)).join("; ");
+            pending.push(withReason);
+        }
+        return { valid, pending };
+    }
+    passes(check, value) {
+        const text = value === null || value === undefined ? "" : String(value).trim();
+        if (text === "")
+            return check.skipEmpty;
+        return check.isValid(text);
+    }
+    buildCheck(rule) {
+        const { column } = rule;
+        switch (rule.rule) {
+            case "required":
+                return {
+                    column,
+                    message: rule.message ?? `${column} vazio`,
+                    skipEmpty: false,
+                    isValid: () => true,
+                };
+            case "pattern": {
+                const flags = (rule.flags ?? "").replace(/[gy]/g, "");
+                const regex = new RegExp(rule.pattern, flags);
+                return {
+                    column,
+                    message: rule.message ?? `${column} fora do formato`,
+                    skipEmpty: true,
+                    isValid: (text) => regex.test(text),
+                };
+            }
+            case "oneOf": {
+                const normalize = (text) => rule.ignoreCase ? text.toLowerCase() : text;
+                const allowed = new Set(rule.values.map((v) => normalize(v.trim())));
+                return {
+                    column,
+                    message: rule.message ?? `${column} com valor não permitido`,
+                    skipEmpty: true,
+                    isValid: (text) => allowed.has(normalize(text)),
+                };
+            }
+            case "normalizer": {
+                const normalizer = (0, registry_1.getKeyNormalizer)(rule.normalizer);
+                return {
+                    column,
+                    message: rule.message ?? `${column} inválido`,
+                    skipEmpty: true,
+                    isValid: (text) => normalizer(text) !== null,
+                };
+            }
+        }
+    }
+}
+exports.RowValidator = RowValidator;

package/dist/filters/validateTypes.d.ts

@@ -0,0 +1,28 @@
+interface BaseRule {
+    column: string;
+    message?: string | undefined;
+}
+export interface RequiredRule extends BaseRule {
+    rule: "required";
+}
+export interface PatternRule extends BaseRule {
+    rule: "pattern";
+    pattern: string;
+    flags?: string | undefined;
+}
+export interface OneOfRule extends BaseRule {
+    rule: "oneOf";
+    values: string[];
+    ignoreCase?: boolean | undefined;
+}
+export interface NormalizerRule extends BaseRule {
+    rule: "normalizer";
+    normalizer: string;
+}
+export type ValidationRule = RequiredRule | PatternRule | OneOfRule | NormalizerRule;
+export interface ValidationConfig {
+    rules: ValidationRule[];
+    pendingSheet?: string | undefined;
+    reasonColumn?: string | undefined;
+}
+export {};

package/dist/filters/validateTypes.js

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

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./api";
+export { runEtl, applySteps, formatReport, parseMode, MODES } from "./pipeline";
+export type { RunEtlOptions, EtlReport, StepReport, PendingReason, Mode, } from "./pipeline";
+export { loadConfig, loadJsonConfig, parseConfig, etlConfigSchema, checkConfigFile, checkConfigText, } from "./config";
+export type { EtlConfig, SourceConfig, DestinationConfig, ConfigCheck, ConfigProblem, } from "./config";
+export { consoleLogger, silentLogger, createMemoryLogger } from "./logger";
+export type { Logger, MemoryLogger } from "./logger";
+export type { Source, Sink, SinkWriteOptions } from "./io/types";
+export { registerSourceAdapter, registerSinkAdapter, } from "./io/custom/registry";
+export type { AdapterContext, AdapterOptions } from "./io/custom/registry";
+export { registerKeyNormalizer } from "./normalizers/registry";
+export type { KeyNormalizer, NormalizedKey } from "./normalizers/registry";
+export type { TableRow } from "./types";

package/dist/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerKeyNormalizer = exports.registerSinkAdapter = exports.registerSourceAdapter = exports.createMemoryLogger = exports.silentLogger = exports.consoleLogger = exports.checkConfigText = exports.checkConfigFile = exports.etlConfigSchema = exports.parseConfig = exports.loadJsonConfig = exports.loadConfig = exports.MODES = exports.parseMode = exports.formatReport = exports.applySteps = exports.runEtl = void 0;
+__exportStar(require("./api"), exports);
+var pipeline_1 = require("./pipeline");
+Object.defineProperty(exports, "runEtl", { enumerable: true, get: function () { return pipeline_1.runEtl; } });
+Object.defineProperty(exports, "applySteps", { enumerable: true, get: function () { return pipeline_1.applySteps; } });
+Object.defineProperty(exports, "formatReport", { enumerable: true, get: function () { return pipeline_1.formatReport; } });
+Object.defineProperty(exports, "parseMode", { enumerable: true, get: function () { return pipeline_1.parseMode; } });
+Object.defineProperty(exports, "MODES", { enumerable: true, get: function () { return pipeline_1.MODES; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return config_1.loadConfig; } });
+Object.defineProperty(exports, "loadJsonConfig", { enumerable: true, get: function () { return config_1.loadJsonConfig; } });
+Object.defineProperty(exports, "parseConfig", { enumerable: true, get: function () { return config_1.parseConfig; } });
+Object.defineProperty(exports, "etlConfigSchema", { enumerable: true, get: function () { return config_1.etlConfigSchema; } });
+Object.defineProperty(exports, "checkConfigFile", { enumerable: true, get: function () { return config_1.checkConfigFile; } });
+Object.defineProperty(exports, "checkConfigText", { enumerable: true, get: function () { return config_1.checkConfigText; } });
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "consoleLogger", { enumerable: true, get: function () { return logger_1.consoleLogger; } });
+Object.defineProperty(exports, "silentLogger", { enumerable: true, get: function () { return logger_1.silentLogger; } });
+Object.defineProperty(exports, "createMemoryLogger", { enumerable: true, get: function () { return logger_1.createMemoryLogger; } });
+var registry_1 = require("./io/custom/registry");
+Object.defineProperty(exports, "registerSourceAdapter", { enumerable: true, get: function () { return registry_1.registerSourceAdapter; } });
+Object.defineProperty(exports, "registerSinkAdapter", { enumerable: true, get: function () { return registry_1.registerSinkAdapter; } });
+var registry_2 = require("./normalizers/registry");
+Object.defineProperty(exports, "registerKeyNormalizer", { enumerable: true, get: function () { return registry_2.registerKeyNormalizer; } });

package/dist/io/csv/csvFormat.d.ts

@@ -0,0 +1,4 @@
+export declare function stripBom(text: string): string;
+export declare function detectDelimiter(text: string): string;
+export declare function parseCsv(text: string, delimiter: string): string[][];
+export declare function toCsv(rows: string[][], delimiter: string): string;

package/dist/io/csv/csvFormat.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripBom = stripBom;
+exports.detectDelimiter = detectDelimiter;
+exports.parseCsv = parseCsv;
+exports.toCsv = toCsv;
+const BOM = "\uFEFF";
+const CANDIDATE_DELIMITERS = [",", ";", "\t", "|"];
+function stripBom(text) {
+    return text.startsWith(BOM) ? text.slice(1) : text;
+}
+function detectDelimiter(text) {
+    let best = ",";
+    let bestCount = 0;
+    for (const delimiter of CANDIDATE_DELIMITERS) {
+        let count = 0;
+        let inQuotes = false;
+        for (const char of text) {
+            if (char === '"')
+                inQuotes = !inQuotes;
+            else if (!inQuotes && (char === "\n" || char === "\r"))
+                break;
+            else if (!inQuotes && char === delimiter)
+                count++;
+        }
+        if (count > bestCount) {
+            best = delimiter;
+            bestCount = count;
+        }
+    }
+    return best;
+}
+function parseCsv(text, delimiter) {
+    const rows = [];
+    let row = [];
+    let field = "";
+    let inQuotes = false;
+    for (let i = 0; i < text.length; i++) {
+        const char = text.charAt(i);
+        if (inQuotes) {
+            if (char === '"' && text[i + 1] === '"') {
+                field += '"';
+                i++;
+            }
+            else if (char === '"') {
+                inQuotes = false;
+            }
+            else {
+                field += char;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inQuotes = true;
+        }
+        else if (text.startsWith(delimiter, i)) {
+            row.push(field);
+            field = "";
+            i += delimiter.length - 1;
+        }
+        else if (char === "\n" || char === "\r") {
+            if (char === "\r" && text[i + 1] === "\n")
+                i++;
+            row.push(field);
+            rows.push(row);
+            row = [];
+            field = "";
+        }
+        else {
+            field += char;
+        }
+    }
+    if (inQuotes) {
+        throw new Error("CSV com aspas abertas que nunca fecham.");
+    }
+    if (field !== "" || row.length > 0) {
+        row.push(field);
+        rows.push(row);
+    }
+    return rows.filter((r) => !(r.length === 1 && r[0] === ""));
+}
+function escapeField(value, delimiter) {
+    const needsQuotes = value.includes(delimiter) ||
+        value.includes('"') ||
+        value.includes("\n") ||
+        value.includes("\r") ||
+        value !== value.trim();
+    return needsQuotes ? `"${value.replace(/"/g, '""')}"` : value;
+}
+function toCsv(rows, delimiter) {
+    return rows
+        .map((row) => row.map((value) => escapeField(value, delimiter)).join(delimiter))
+        .join("\r\n");
+}

package/dist/io/csv/csvSink.d.ts

@@ -0,0 +1,14 @@
+import { TableRow } from "../../types";
+import { Sink, SinkWriteOptions } from "../types";
+import { Logger } from "../../logger";
+export interface CsvSinkOptions {
+    path: string;
+    delimiter?: string | undefined;
+    bom?: boolean | undefined;
+}
+export declare class CsvSink implements Sink {
+    private readonly options;
+    private readonly logger;
+    constructor(options: CsvSinkOptions, logger?: Logger);
+    write(rows: TableRow[], options?: SinkWriteOptions): Promise<void>;
+}

package/dist/io/csv/csvSink.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CsvSink = void 0;
+const header_1 = require("../header");
+const csvFormat_1 = require("./csvFormat");
+const files_1 = require("../files");
+const logger_1 = require("../../logger");
+class CsvSink {
+    options;
+    logger;
+    constructor(options, logger = logger_1.consoleLogger) {
+        this.options = options;
+        this.logger = logger;
+    }
+    async write(rows, options = {}) {
+        const filePath = (0, files_1.extraOutputPath)(this.options.path, options.name);
+        const header = (0, header_1.buildHeader)(rows);
+        const lines = rows.map((row) => header.map((column) => {
+            const value = row[column];
+            return value === null || value === undefined
+                ? ""
+                : String(value);
+        }));
+        const content = rows.length === 0
+            ? ""
+            : (0, csvFormat_1.toCsv)([header, ...lines], this.options.delimiter ?? ",");
+        const bom = (this.options.bom ?? true) ? "\uFEFF" : "";
+        (0, files_1.writeTextFile)(filePath, bom + content + (content ? "\r\n" : ""));
+        this.logger.info(`${rows.length} linhas escritas em ${filePath}.`);
+    }
+}
+exports.CsvSink = CsvSink;

package/dist/io/csv/csvSource.d.ts

@@ -0,0 +1,13 @@
+import { TableRow } from "../../types";
+import { Source } from "../types";
+import { FileEncoding } from "../files";
+export interface CsvSourceOptions {
+    path: string;
+    delimiter?: string | undefined;
+    encoding?: FileEncoding | undefined;
+}
+export declare class CsvSource implements Source {
+    private readonly options;
+    constructor(options: CsvSourceOptions);
+    read(): Promise<TableRow[]>;
+}

package/dist/io/csv/csvSource.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CsvSource = void 0;
+const csvFormat_1 = require("./csvFormat");
+const files_1 = require("../files");
+class CsvSource {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async read() {
+        const text = (0, csvFormat_1.stripBom)((0, files_1.readTextFile)(this.options.path, this.options.encoding));
+        const delimiter = this.options.delimiter ?? (0, csvFormat_1.detectDelimiter)(text);
+        const [header, ...lines] = (0, csvFormat_1.parseCsv)(text, delimiter);
+        if (!header)
+            return [];
+        const columns = header.map((column) => column.trim());
+        return lines.map((values) => {
+            const row = {};
+            columns.forEach((column, index) => {
+                const value = values[index];
+                row[column] =
+                    value === undefined || value === "" ? null : value;
+            });
+            return row;
+        });
+    }
+}
+exports.CsvSource = CsvSource;

package/dist/io/custom/loader.d.ts

@@ -0,0 +1 @@
+export declare function loadAdapterModules(modulePaths: string[]): void;

package/dist/io/custom/loader.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAdapterModules = loadAdapterModules;
+const path_1 = __importDefault(require("path"));
+const registry_1 = require("./registry");
+function registerAll(modulePath, group, register) {
+    for (const [name, factory] of Object.entries(group ?? {})) {
+        if (typeof factory !== "function") {
+            throw new Error(`Em "${modulePath}", "${name}" não é uma função.`);
+        }
+        register(name, factory);
+    }
+}
+function loadAdapterModules(modulePaths) {
+    for (const modulePath of modulePaths) {
+        let loaded;
+        try {
+            loaded = require(path_1.default.resolve(modulePath));
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            throw new Error(`Não consegui carregar o módulo de adapters "${modulePath}": ${reason}`);
+        }
+        const adapters = (loaded ?? {});
+        const hasSources = typeof adapters.sources === "object" && adapters.sources !== null;
+        const hasSinks = typeof adapters.sinks === "object" && adapters.sinks !== null;
+        if (!hasSources && !hasSinks) {
+            throw new Error(`O módulo "${modulePath}" precisa exportar um objeto "sources", um objeto "sinks" ou os dois. Exemplo: export const sources = { minhaFonte };`);
+        }
+        registerAll(modulePath, adapters.sources, registry_1.registerSourceAdapter);
+        registerAll(modulePath, adapters.sinks, registry_1.registerSinkAdapter);
+    }
+}

package/dist/io/custom/registry.d.ts

@@ -0,0 +1,13 @@
+import { Sink, Source } from "../types";
+import { Logger } from "../../logger";
+export type AdapterOptions = Record<string, unknown>;
+export interface AdapterContext {
+    logger: Logger;
+}
+export type SourceFactory = (options: AdapterOptions, context: AdapterContext) => Source;
+export type SinkFactory = (options: AdapterOptions, context: AdapterContext) => Sink;
+export declare function registerSourceAdapter(name: string, factory: SourceFactory): void;
+export declare function registerSinkAdapter(name: string, factory: SinkFactory): void;
+export declare function createCustomSource(name: string, options: AdapterOptions, logger?: Logger): Source;
+export declare function createCustomSink(name: string, options: AdapterOptions, logger?: Logger): Sink;
+export declare function clearCustomAdapters(): void;

package/dist/io/custom/registry.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSourceAdapter = registerSourceAdapter;
+exports.registerSinkAdapter = registerSinkAdapter;
+exports.createCustomSource = createCustomSource;
+exports.createCustomSink = createCustomSink;
+exports.clearCustomAdapters = clearCustomAdapters;
+const logger_1 = require("../../logger");
+const sources = new Map();
+const sinks = new Map();
+function register(registry, kind, name, factory) {
+    const existing = registry.get(name);
+    if (existing && existing !== factory) {
+        throw new Error(`Já existe ${kind} registrado com o nome "${name}".`);
+    }
+    registry.set(name, factory);
+}
+function find(registry, kind, name) {
+    const factory = registry.get(name);
+    if (!factory) {
+        const available = Array.from(registry.keys());
+        const hint = available.length > 0 ? available.join(", ") : "nenhum registrado";
+        throw new Error(`${kind} "${name}" não encontrado. Disponíveis: ${hint}`);
+    }
+    return factory;
+}
+function registerSourceAdapter(name, factory) {
+    register(sources, "uma fonte", name, factory);
+}
+function registerSinkAdapter(name, factory) {
+    register(sinks, "um destino", name, factory);
+}
+function createCustomSource(name, options, logger = logger_1.consoleLogger) {
+    const source = find(sources, "Fonte", name)(options, { logger });
+    if (typeof source?.read !== "function") {
+        throw new Error(`A fonte "${name}" precisa devolver um objeto com o método read().`);
+    }
+    return source;
+}
+function createCustomSink(name, options, logger = logger_1.consoleLogger) {
+    const sink = find(sinks, "Destino", name)(options, { logger });
+    if (typeof sink?.write !== "function") {
+        throw new Error(`O destino "${name}" precisa devolver um objeto com o método write().`);
+    }
+    return sink;
+}
+function clearCustomAdapters() {
+    sources.clear();
+    sinks.clear();
+}

package/dist/io/excel/excelCell.d.ts

@@ -0,0 +1,4 @@
+import type { CellValue as ExcelCellValue } from "exceljs";
+type CellValue = string | number | null;
+export declare function fromExcelCell(value: ExcelCellValue | undefined): CellValue;
+export {};

package/dist/io/excel/excelCell.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromExcelCell = fromExcelCell;
+function isoDate(date) {
+    const iso = date.toISOString();
+    return iso.endsWith("T00:00:00.000Z") ? iso.slice(0, 10) : iso;
+}
+function fromExcelCell(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === "number")
+        return value;
+    if (typeof value === "string")
+        return value === "" ? null : value;
+    if (typeof value === "boolean")
+        return String(value);
+    if (value instanceof Date)
+        return isoDate(value);
+    if ("richText" in value) {
+        return fromExcelCell(value.richText.map((part) => part.text).join(""));
+    }
+    if ("formula" in value || "sharedFormula" in value) {
+        return fromExcelCell(value.result);
+    }
+    if ("hyperlink" in value) {
+        return fromExcelCell(value.text);
+    }
+    return null;
+}

package/dist/io/excel/excelSink.d.ts

@@ -0,0 +1,14 @@
+import { TableRow } from "../../types";
+import { Sink, SinkWriteOptions } from "../types";
+import { Logger } from "../../logger";
+export interface ExcelSinkOptions {
+    path: string;
+    sheet?: string | undefined;
+}
+export declare function safeSheetName(name: string): string;
+export declare class ExcelSink implements Sink {
+    private readonly options;
+    private readonly logger;
+    constructor(options: ExcelSinkOptions, logger?: Logger);
+    write(rows: TableRow[], options?: SinkWriteOptions): Promise<void>;
+}

package/dist/io/excel/excelSink.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExcelSink = void 0;
+exports.safeSheetName = safeSheetName;
+const fs_1 = __importDefault(require("fs"));
+const header_1 = require("../header");
+const workbook_1 = require("./workbook");
+const logger_1 = require("../../logger");
+const DEFAULT_SHEET = "Dados";
+const MAX_SHEET_NAME = 31;
+function safeSheetName(name) {
+    const clean = name
+        .replace(/[[\]:*?/\\]/g, " ")
+        .trim()
+        .slice(0, MAX_SHEET_NAME);
+    return clean || DEFAULT_SHEET;
+}
+class ExcelSink {
+    options;
+    logger;
+    constructor(options, logger = logger_1.consoleLogger) {
+        this.options = options;
+        this.logger = logger;
+    }
+    async write(rows, options = {}) {
+        const isMain = options.name === undefined;
+        const sheetName = safeSheetName(options.name ?? this.options.sheet ?? DEFAULT_SHEET);
+        const workbook = !isMain && fs_1.default.existsSync(this.options.path)
+            ? await (0, workbook_1.openWorkbook)(this.options.path)
+            : (0, workbook_1.createWorkbook)();
+        if (!isMain) {
+            const old = workbook.getWorksheet(sheetName);
+            if (old)
+                workbook.removeWorksheet(old.id);
+        }
+        const worksheet = workbook.addWorksheet(sheetName, {
+            views: [{ state: "frozen", ySplit: 1 }],
+        });
+        const header = (0, header_1.buildHeader)(rows);
+        if (header.length > 0) {
+            worksheet.addRow(header).font = { bold: true };
+            for (const row of rows) {
+                worksheet.addRow(header.map((column) => row[column] ?? null));
+            }
+            header.forEach((column, index) => {
+                const longest = Math.max(column.length, ...rows.map((row) => String(row[column] ?? "").length));
+                worksheet.getColumn(index + 1).width = Math.min(Math.max(longest + 2, 10), 50);
+            });
+        }
+        await (0, workbook_1.saveWorkbook)(workbook, this.options.path);
+        this.logger.info(`${rows.length} linhas escritas na aba "${sheetName}" de ${this.options.path}.`);
+    }
+}
+exports.ExcelSink = ExcelSink;

package/dist/io/excel/excelSource.d.ts

@@ -0,0 +1,11 @@
+import { TableRow } from "../../types";
+import { Source } from "../types";
+export interface ExcelSourceOptions {
+    path: string;
+    sheet?: string | undefined;
+}
+export declare class ExcelSource implements Source {
+    private readonly options;
+    constructor(options: ExcelSourceOptions);
+    read(): Promise<TableRow[]>;
+}

package/dist/io/excel/excelSource.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExcelSource = void 0;
+const workbook_1 = require("./workbook");
+const excelCell_1 = require("./excelCell");
+class ExcelSource {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async read() {
+        const workbook = await (0, workbook_1.openWorkbook)(this.options.path);
+        const sheetName = this.options.sheet;
+        const worksheet = sheetName === undefined
+            ? workbook.worksheets[0]
+            : workbook.getWorksheet(sheetName);
+        if (!worksheet) {
+            const names = workbook.worksheets.map((ws) => ws.name).join(", ");
+            throw new Error(sheetName === undefined
+                ? `O arquivo ${this.options.path} não tem nenhuma aba.`
+                : `Aba "${sheetName}" não encontrada em ${this.options.path}. Abas: ${names}`);
+        }
+        const header = new Map();
+        worksheet.getRow(1).eachCell((cell, column) => {
+            const name = (0, excelCell_1.fromExcelCell)(cell.value);
+            if (name !== null)
+                header.set(column, String(name).trim());
+        });
+        const rows = [];
+        worksheet.eachRow((excelRow, rowNumber) => {
+            if (rowNumber === 1)
+                return;
+            const row = {};
+            let hasValue = false;
+            for (const [column, name] of header) {
+                const value = (0, excelCell_1.fromExcelCell)(excelRow.getCell(column).value);
+                row[name] = value;
+                if (value !== null)
+                    hasValue = true;
+            }
+            if (hasValue)
+                rows.push(row);
+        });
+        return rows;
+    }
+}
+exports.ExcelSource = ExcelSource;

package/dist/io/excel/workbook.d.ts

@@ -0,0 +1,4 @@
+import type { Workbook } from "exceljs";
+export declare function createWorkbook(): Workbook;
+export declare function openWorkbook(filePath: string): Promise<Workbook>;
+export declare function saveWorkbook(workbook: Workbook, filePath: string): Promise<void>;

package/dist/io/excel/workbook.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkbook = createWorkbook;
+exports.openWorkbook = openWorkbook;
+exports.saveWorkbook = saveWorkbook;
+const optional_1 = require("../optional");
+const files_1 = require("../files");
+function createWorkbook() {
+    const exceljs = (0, optional_1.requireOptional)(() => require("exceljs"), ["exceljs"], "Excel");
+    return new exceljs.Workbook();
+}
+async function openWorkbook(filePath) {
+    const workbook = createWorkbook();
+    await workbook.xlsx.load((0, files_1.readBinaryFile)(filePath));
+    return workbook;
+}
+async function saveWorkbook(workbook, filePath) {
+    const buffer = await workbook.xlsx.writeBuffer();
+    (0, files_1.writeBinaryFile)(filePath, Buffer.from(buffer));
+}