@forzalabs/remora 1.0.21 → 1.1.1

package/engines/dataset/DatasetManager.js

@@ -1,211 +0,0 @@
-"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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const Affirm_1 = __importDefault(require("../../core/Affirm"));
-const ParseManager_1 = __importDefault(require("../parsing/ParseManager"));
-const Dataset_1 = __importDefault(require("./Dataset"));
-const DeveloperEngine_1 = __importDefault(require("../ai/DeveloperEngine"));
-const Constants_1 = __importDefault(require("../../Constants"));
-const ProducerManager_1 = __importDefault(require("../producer/ProducerManager"));
-class DatasetManagerClass {
-    constructor() {
-        /**
-         * Create a new Dataset for a producer. If an executionId is provided, the dataset files will
-         * be isolated inside a sub-folder specific to that execution to avoid concurrency conflicts
-         * when the same producer / consumer is executed multiple times in parallel.
-         */
-        this.create = (producer, options) => {
-            var _a, _b;
-            (0, Affirm_1.default)(producer, 'Invalid producer');
-            const { name, settings: { delimiter, fileKey, fileType, hasHeaderRow, sheetName, httpApi } } = producer;
-            const executionId = options === null || options === void 0 ? void 0 : options.executionId;
-            const cProducer = options === null || options === void 0 ? void 0 : options.cProducer;
-            // Check if any dimension has sourceFilename flag set to true
-            const hasSourceFilenameDimension = (_b = (_a = producer.dimensions) === null || _a === void 0 ? void 0 : _a.some(d => d.sourceFilename === true)) !== null && _b !== void 0 ? _b : false;
-            const dataset = new Dataset_1.default({
-                name,
-                baseProducer: producer,
-                file: {
-                    fileKey,
-                    fileType,
-                    hasHeaderRow,
-                    sheetName,
-                    delimiter,
-                    httpApi,
-                    includeSourceFilename: hasSourceFilenameDimension,
-                    isOptional: cProducer === null || cProducer === void 0 ? void 0 : cProducer.isOptional
-                },
-                executionId
-            });
-            return dataset;
-        };
-        this.buildDimensionsFromFirstLine = (firstLine_1, dsFile_1, producer_1, ...args_1) => __awaiter(this, [firstLine_1, dsFile_1, producer_1, ...args_1], void 0, function* (firstLine, dsFile, producer, discover = false) {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
-            Affirm_1.default.hasValue(firstLine, `Invalid first line`);
-            (0, Affirm_1.default)(dsFile, `Invalid dataset file`);
-            (0, Affirm_1.default)(producer, `Invalid producer`);
-            const file = dsFile;
-            switch (file.fileType) {
-                case 'CSV': {
-                    const delimiterChar = (_a = file.delimiter) !== null && _a !== void 0 ? _a : ',';
-                    const headerLine = firstLine;
-                    const rawDimensions = ParseManager_1.default._extractHeader(headerLine, delimiterChar, producer, discover);
-                    return {
-                        dimensions: rawDimensions.map(x => ({
-                            key: x.name,
-                            name: x.saveAs,
-                            index: x.index,
-                            hidden: null,
-                            type: x.type
-                        })),
-                        delimiter: delimiterChar
-                    };
-                }
-                case 'PARQUET':
-                case 'JSONL':
-                case 'JSON': {
-                    const columns = ProducerManager_1.default.getColumns(producer);
-                    const firstObject = JSON.parse(firstLine);
-                    const keys = Object.keys(firstObject);
-                    // const columnsWithDot = columns.filter(x => x.aliasInProducer.includes('.'))
-                    // if (columnsWithDot.length > 0) {
-                    //     console.log(columns, keys, 'PAPAPAPP')
-                    //     for (const colWithDot of columnsWithDot) {
-                    //         console.log(colWithDot)
-                    //     }
-                    // }
-                    // If includeSourceFilename is enabled, the driver has added $source_filename column
-                    // We need to add it to the keys list so dimensions can reference it
-                    const includeSourceFilename = file.includeSourceFilename === true;
-                    if (includeSourceFilename) {
-                        keys.push(Constants_1.default.SOURCE_FILENAME_COLUMN);
-                    }
-                    if (discover) {
-                        return {
-                            delimiter: (_b = file.delimiter) !== null && _b !== void 0 ? _b : ',',
-                            dimensions: keys.map((x, i) => ({
-                                hidden: false,
-                                index: i,
-                                key: x,
-                                name: x,
-                                type: DeveloperEngine_1.default.inferDimensionType(firstObject === null || firstObject === void 0 ? void 0 : firstObject[x])
-                            }))
-                        };
-                    }
-                    const dimensions = [];
-                    for (const pColumn of columns) {
-                        // Handle sourceFilename dimension specially - it maps to the $source_filename column added by the driver
-                        if (((_c = pColumn.dimension) === null || _c === void 0 ? void 0 : _c.sourceFilename) === true) {
-                            if (includeSourceFilename) {
-                                const sourceFilenameIndex = keys.findIndex(x => x === Constants_1.default.SOURCE_FILENAME_COLUMN);
-                                dimensions.push({
-                                    index: sourceFilenameIndex,
-                                    key: Constants_1.default.SOURCE_FILENAME_COLUMN,
-                                    name: pColumn.nameInProducer,
-                                    hidden: null,
-                                    type: (_e = (_d = pColumn.dimension) === null || _d === void 0 ? void 0 : _d.type) !== null && _e !== void 0 ? _e : 'string'
-                                });
-                            }
-                            continue;
-                        }
-                        const columnKey = (_f = pColumn.aliasInProducer) !== null && _f !== void 0 ? _f : pColumn.nameInProducer;
-                        const csvColumnIndex = keys.findIndex(x => x === columnKey);
-                        (0, Affirm_1.default)(csvColumnIndex > -1, `The column "${pColumn.nameInProducer}" (with key "${columnKey}") of producer "${producer.name}" doesn't exist in the underlying dataset.`);
-                        dimensions.push({
-                            index: csvColumnIndex,
-                            key: columnKey,
-                            name: pColumn.nameInProducer,
-                            hidden: null,
-                            type: (_h = (_g = pColumn.dimension) === null || _g === void 0 ? void 0 : _g.type) !== null && _h !== void 0 ? _h : 'string'
-                        });
-                    }
-                    const delimiterChar = (_j = file.delimiter) !== null && _j !== void 0 ? _j : ',';
-                    return { dimensions, delimiter: delimiterChar };
-                }
-                case 'TXT': {
-                    if (!file.hasHeaderRow) {
-                        // If the file is a TXT and there isn't an header row, then I add a fake one that maps directly to the producer
-                        const delimiterChar = (_k = file.delimiter) !== null && _k !== void 0 ? _k : ',';
-                        const columns = ProducerManager_1.default.getColumns(producer);
-                        const includeSourceFilename = file.includeSourceFilename === true;
-                        if (discover) {
-                            // Since I don't have an header, and I'm discovering, I just create placeholder dimensions based on the same number of columns of the txt
-                            const colValues = firstLine.split(delimiterChar);
-                            const dimensions = colValues.map((x, i) => ({
-                                hidden: false,
-                                index: i,
-                                key: `Col ${i + 1}`,
-                                name: `Col ${i + 1}`,
-                                type: 'string'
-                            }));
-                            return {
-                                delimiter: delimiterChar,
-                                dimensions
-                            };
-                        }
-                        // Filter out sourceFilename columns for index-based mapping, but track them for later
-                        const regularColumns = columns.filter(x => { var _a; return ((_a = x.dimension) === null || _a === void 0 ? void 0 : _a.sourceFilename) !== true; });
-                        const sourceFilenameColumn = columns.find(x => { var _a; return ((_a = x.dimension) === null || _a === void 0 ? void 0 : _a.sourceFilename) === true; });
-                        const dimensions = regularColumns.map((x, i) => {
-                            var _a, _b, _c;
-                            return ({
-                                key: (_a = x.aliasInProducer) !== null && _a !== void 0 ? _a : x.nameInProducer,
-                                name: x.nameInProducer,
-                                index: i,
-                                hidden: null,
-                                type: (_c = (_b = x.dimension) === null || _b === void 0 ? void 0 : _b.type) !== null && _c !== void 0 ? _c : 'string'
-                            });
-                        });
-                        // Add sourceFilename dimension at the end if enabled
-                        if (sourceFilenameColumn && includeSourceFilename) {
-                            dimensions.push({
-                                key: Constants_1.default.SOURCE_FILENAME_COLUMN,
-                                name: sourceFilenameColumn.nameInProducer,
-                                index: regularColumns.length, // Index after all regular columns
-                                hidden: null,
-                                type: (_m = (_l = sourceFilenameColumn.dimension) === null || _l === void 0 ? void 0 : _l.type) !== null && _m !== void 0 ? _m : 'string'
-                            });
-                        }
-                        return {
-                            dimensions,
-                            delimiter: delimiterChar
-                        };
-                    }
-                    else {
-                        const delimiterChar = (_o = producer.settings.delimiter) !== null && _o !== void 0 ? _o : ',';
-                        const rawDimensions = ParseManager_1.default._extractHeader(firstLine, delimiterChar, producer, discover);
-                        return {
-                            dimensions: rawDimensions.map(x => ({
-                                key: x.name,
-                                name: x.saveAs,
-                                index: x.index,
-                                hidden: null,
-                                type: x.type
-                            })),
-                            delimiter: delimiterChar
-                        };
-                    }
-                }
-                case 'XLS':
-                    break;
-                case 'XLSX':
-                    break;
-                case 'XML':
-                    break;
-            }
-        });
-    }
-}
-const DatasetManager = new DatasetManagerClass();
-exports.default = DatasetManager;

package/engines/dataset/DatasetRecord.js

@@ -1,120 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const Algo_1 = __importDefault(require("../../core/Algo"));
-const CSVParser_1 = __importDefault(require("../parsing/CSVParser"));
-const TypeCaster_1 = __importDefault(require("../transform/TypeCaster"));
-class DatasetRecord {
-    constructor(row, dimensions, delimiter) {
-        this.parse = (row, delimiter, dimensions) => {
-            if (!this.isEmpty() && dimensions.length > 0) {
-                const parts = CSVParser_1.default.parseRow(row, delimiter);
-                for (let i = 0; i < dimensions.length; i++) {
-                    const dim = dimensions[i];
-                    // Use dim.index to get the correct column from the file, not the loop index
-                    this._value[dim.name] = TypeCaster_1.default.cast(parts[dim.index], dim.type, dim.format);
-                }
-            }
-        };
-        this.stringify = () => this._dimensions.map(x => `"${this._value[x.name]}"`).join(this._delimiter);
-        this.isEmpty = () => { var _a; return ((_a = this._row) === null || _a === void 0 ? void 0 : _a.trim().length) === 0; };
-        this.getRaw = () => this._row;
-        this.getValue = (dimension) => this._value[dimension];
-        this.setValue = (dimension, value) => {
-            this._value[dimension] = value;
-            return this;
-        };
-        /**
-         * Reinitialize the record with new data instead of creating a new instance
-         * This is used for object pooling optimization
-         */
-        this.reinitialize = (row, dimensions, delimiter) => {
-            this._row = row;
-            this._dimensions = dimensions;
-            this._delimiter = delimiter;
-            this._value = {};
-            this.parse(row, delimiter, this._dimensions);
-        };
-        this.wholeUpdateDimension = (update) => {
-            var _a, _b, _c, _d, _e;
-            if (update.toDelete) {
-                // To remove
-                delete this._value[update.currentDimension.name];
-                if (this._dimensions.some(x => x.key === update.currentDimension.name))
-                    this._dimensions = this._dimensions.filter(x => x.key !== update.currentDimension.name);
-                else
-                    this._dimensions = this._dimensions.filter(x => x.key !== update.currentDimension.key);
-            }
-            else if (!update.currentDimension) {
-                // To create (at the right position)
-                const newDimension = {
-                    index: update.newPosition,
-                    key: update.newName,
-                    name: update.newName,
-                    hidden: update.newHidden,
-                    type: (_b = (_a = update.currentDimension) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : 'string'
-                };
-                this._value[newDimension.name] = null;
-                this._dimensions = [...this._dimensions, newDimension];
-            }
-            else {
-                // Change: name, hidden, position
-                let index = this._dimensions.findIndex(x => x.key === update.currentDimension.name);
-                if (index < 0)
-                    index = this._dimensions.findIndex(x => x.key === update.currentDimension.key);
-                const currentDim = this._dimensions[index];
-                const updatedDim = {
-                    name: update.newName,
-                    key: (_c = currentDim.key) !== null && _c !== void 0 ? _c : update.newName,
-                    hidden: update.newHidden,
-                    index: update.newPosition,
-                    type: (_e = (_d = update.currentDimension) === null || _d === void 0 ? void 0 : _d.type) !== null && _e !== void 0 ? _e : 'string'
-                };
-                this._value[updatedDim.name] = this._value[currentDim.name];
-                if (updatedDim.name !== currentDim.name)
-                    delete this._value[currentDim.name];
-                const newDimensions = [...this._dimensions];
-                newDimensions.splice(index, 1, updatedDim);
-                this._dimensions = newDimensions;
-            }
-            return this;
-        };
-        this.sortDimensions = () => {
-            const isOutOfOrder = this._dimensions.some((dim, index) => dim.index !== index);
-            if (isOutOfOrder) {
-                this._dimensions.sort((a, b) => a.index - b.index);
-            }
-        };
-        this.toJSON = () => {
-            if (this._dimensions.some(x => x.hidden)) {
-                // remove the not wanted dimension
-                const clonedValue = structuredClone(this._value);
-                for (const dim of this._dimensions) {
-                    if (dim.hidden)
-                        delete clonedValue[dim.name];
-                }
-                return JSON.stringify(clonedValue);
-            }
-            else {
-                return JSON.stringify(this._value);
-            }
-        };
-        this.toCSV = (delimiter) => {
-            const myDelimtier = delimiter !== null && delimiter !== void 0 ? delimiter : this._delimiter;
-            // remove the not wanted dimension
-            const line = this._dimensions
-                .filter(x => !x.hidden)
-                .map(x => { var _a, _b; return `"${Algo_1.default.replaceAll((_b = (_a = this._value[x.name]) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : '', '"', '""')}"`; })
-                .join(myDelimtier);
-            return line;
-        };
-        this._row = row;
-        this._dimensions = dimensions;
-        this._delimiter = delimiter;
-        this._value = {};
-        this.parse(row, delimiter, this._dimensions);
-    }
-}
-exports.default = DatasetRecord;

package/engines/dataset/DatasetRecordPool.js

@@ -1,77 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const DatasetRecord_1 = __importDefault(require("./DatasetRecord"));
-/**
- * A pool of DatasetRecord objects to optimize memory allocation during batch processing
- */
-class DatasetRecordPool {
-    constructor(poolSize) {
-        /**
-         * Initialize the pool with empty DatasetRecord objects
-         */
-        this._initializePool = () => {
-            this._pool = [];
-            for (let i = 0; i < this._poolSize; i++) {
-                this._pool.push(new DatasetRecord_1.default('', [], ','));
-            }
-            this._poolIndex = 0;
-        };
-        /**
-         * Get the next available record from the pool and reinitialize it with new data
-         * @param line The raw line data
-         * @param dimensions The dataset dimensions
-         * @param delimiter The delimiter to use
-         * @returns A reinitialized DatasetRecord from the pool
-         */
-        this.getNext = (line, dimensions, delimiter) => {
-            const record = this._pool[this._poolIndex];
-            record.reinitialize(line, dimensions, delimiter);
-            this._poolIndex = (this._poolIndex + 1) % this._poolSize;
-            return record;
-        };
-        /**
-         * Reset the pool index to start from the beginning
-         * This should be called when starting a new batch
-         */
-        this.reset = () => {
-            this._poolIndex = 0;
-        };
-        /**
-         * Update the pool size and reinitialize if necessary
-         * @param newSize The new pool size
-         */
-        this.resize = (newSize) => {
-            if (newSize !== this._poolSize) {
-                this._poolSize = newSize;
-                this._initializePool();
-            }
-        };
-        /**
-         * Update all pooled records with new dimensions and delimiter
-         * This should be called when dataset dimensions change
-         * @param dimensions The new dimensions
-         * @param delimiter The new delimiter
-         */
-        this.updateDimensions = (dimensions, delimiter) => {
-            for (const record of this._pool) {
-                record.reinitialize('', dimensions, delimiter);
-            }
-        };
-        /**
-         * Get the current pool size
-         */
-        this.getSize = () => this._poolSize;
-        /**
-         * Get the current pool index
-         */
-        this.getCurrentIndex = () => this._poolIndex;
-        this._poolSize = poolSize;
-        this._poolIndex = 0;
-        this._pool = [];
-        this._initializePool();
-    }
-}
-exports.default = DatasetRecordPool;

package/engines/execution/RequestExecutor.js

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class RequestExecutorClass {
-    constructor() {
-        this.evaluateFilter = (record, filter) => {
-            const evaluate = (baseRecord, baseFilter) => {
-                const { member, operator, values } = baseFilter;
-                const value = baseRecord[member];
-                const singleValue = values[0];
-                switch (operator) {
-                    case 'equals':
-                        return value === singleValue;
-                    case 'notEquals':
-                        return value !== singleValue;
-                    case 'contains':
-                        return typeof value === 'string' && value.includes(singleValue);
-                    case 'notContains':
-                        return typeof value === 'string' && !value.includes(singleValue);
-                    case 'startsWith':
-                        return typeof value === 'string' && value.startsWith(singleValue);
-                    case 'endsWith':
-                        return typeof value === 'string' && value.endsWith(singleValue);
-                    case 'greaterThan':
-                        return typeof value === 'number' && value > Number(singleValue);
-                    case 'greaterThanOrEquals':
-                        return typeof value === 'number' && value >= Number(singleValue);
-                    case 'lessThan':
-                        return typeof value === 'number' && value < Number(singleValue);
-                    case 'lessThanOrEquals':
-                        return typeof value === 'number' && value <= Number(singleValue);
-                    case 'in':
-                        return values.includes(value);
-                    case 'notIn':
-                        return !values.includes(value);
-                    case 'between':
-                        return values.length === 2 && value >= values[0] && value <= values[1];
-                    case 'notBetween':
-                        return values.length === 2 && (value < values[0] || value > values[1]);
-                    case 'isNull':
-                        return value === null || value === undefined;
-                    case 'isNotNull':
-                        return value !== null && value !== undefined;
-                    case 'true':
-                        return value === true;
-                    case 'false':
-                        return value === false;
-                    case 'matches':
-                        return typeof value === 'string' && new RegExp(singleValue).test(value);
-                    case 'notMatches':
-                        return typeof value === 'string' && !new RegExp(singleValue).test(value);
-                    default:
-                        throw new Error(`Unsupported filter operator: ${operator}`);
-                }
-            };
-            const { and, or } = filter;
-            const baseResult = evaluate(record, filter);
-            if (and)
-                return baseResult && and.every(subFilter => this.evaluateFilter(record, subFilter));
-            if (or)
-                return baseResult || or.some(subFilter => this.evaluateFilter(record, subFilter));
-            else
-                return baseResult;
-        };
-    }
-}
-const RequestExecutor = new RequestExecutorClass();
-exports.default = RequestExecutor;

package/engines/parsing/CSVParser.js

@@ -1,60 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const Affirm_1 = __importDefault(require("../../core/Affirm"));
-class CSVParserClass {
-    constructor() {
-        this.parseRow = (row, delimiter) => {
-            (0, Affirm_1.default)(row, 'Invalid row');
-            (0, Affirm_1.default)(delimiter, 'Invalid delimiter');
-            const fields = [];
-            const len = row.length;
-            let fieldStart = 0;
-            let fieldEnd = 0;
-            let inQuotes = false;
-            let hasQuotes = false;
-            let i = 0;
-            while (i < len) {
-                const char = row.charCodeAt(i);
-                if (char === 34) { // '"'
-                    if (!inQuotes) {
-                        inQuotes = true;
-                        hasQuotes = true;
-                        fieldStart = i + 1;
-                    }
-                    else if (row.charCodeAt(i + 1) === 34) {
-                        i++; // Skip escaped quote, will handle in extraction
-                    }
-                    else {
-                        inQuotes = false;
-                        fieldEnd = i;
-                    }
-                }
-                else if (char === delimiter.charCodeAt(0) && !inQuotes) {
-                    // Extract field
-                    const field = hasQuotes
-                        ? row.slice(fieldStart, fieldEnd).replaceAll('""', '"')
-                        : row.slice(fieldStart, i).trim();
-                    fields.push(field);
-                    fieldStart = i + 1;
-                    fieldEnd = 0;
-                    hasQuotes = false;
-                }
-                else if ((char === 13 || char === 10) && !inQuotes) { // \r or \n
-                    break;
-                }
-                i++;
-            }
-            // Add the last field
-            const field = hasQuotes
-                ? row.slice(fieldStart, fieldEnd).replaceAll('""', '"')
-                : row.slice(fieldStart, i).trim();
-            fields.push(field);
-            return fields;
-        };
-    }
-}
-const CSVParser = new CSVParserClass();
-exports.default = CSVParser;

package/engines/parsing/LineParser.js

@@ -1,71 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const TypeCaster_1 = __importDefault(require("../transform/TypeCaster"));
-const CSVParser_1 = __importDefault(require("./CSVParser"));
-class LineParserClass {
-    constructor() {
-        this.parse = (line, producer, dimensions, tracker) => {
-            var _a;
-            const { settings: { fileType, delimiter } } = producer;
-            switch (fileType) {
-                case 'PARQUET':
-                case 'TXT':
-                case 'XML':
-                case 'XLS':
-                case 'XLSX':
-                case 'CSV': {
-                    let counter = performance.now();
-                    const parts = CSVParser_1.default.parseRow(line, delimiter !== null && delimiter !== void 0 ? delimiter : ',');
-                    tracker.measure('process-line:parse-csv-row', performance.now() - counter);
-                    counter = performance.now();
-                    const value = {};
-                    for (const dim of dimensions) {
-                        value[dim.name] = TypeCaster_1.default.cast(parts[dim.index], dim.prodDimension.type, dim.prodDimension.format);
-                    }
-                    tracker.measure('process-line:cast&build-record', performance.now() - counter);
-                    return value;
-                }
-                case 'JSON':
-                case 'JSONL': {
-                    let counter = performance.now();
-                    const parsed = JSON.parse(line);
-                    tracker.measure('process-line:parse-json', performance.now() - counter);
-                    counter = performance.now();
-                    const value = {};
-                    for (const dim of dimensions) {
-                        const key = (_a = dim.prodDimension.alias) !== null && _a !== void 0 ? _a : dim.prodDimension.name;
-                        value[dim.name] = TypeCaster_1.default.cast(parsed[key], dim.prodDimension.type);
-                    }
-                    tracker.measure('process-line:cast&build-record', performance.now() - counter);
-                    return value;
-                }
-                default:
-                    throw new Error(`File type ${fileType} not implemented yet.`);
-            }
-        };
-        /**
-         * Used ONLY to parse internal records (inside the .dataset) since I know they are already prepared in the correct way
-         */
-        this._internalParseCSV = (line, fields, delimiter) => {
-            var _a, _b;
-            const parts = CSVParser_1.default.parseRow(line, delimiter !== null && delimiter !== void 0 ? delimiter : ',');
-            const record = {};
-            for (const [index, field] of fields.entries()) {
-                const fieldKey = field.finalKey;
-                record[fieldKey] = TypeCaster_1.default.cast(parts[index], (_b = (_a = field.dimension) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : 'string');
-            }
-            return record;
-        };
-        /**
-         * Used ONLY to parse internal records (inside the .dataset) since I know they are already prepared in the correct way
-         */
-        this._internalParseJSON = (line) => {
-            return JSON.parse(line);
-        };
-    }
-}
-const LineParser = new LineParserClass();
-exports.default = LineParser;