@forzalabs/remora 1.0.21 → 1.1.1

package/engines/transform/JoinEngine.js

@@ -1,232 +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 Environment_1 = __importDefault(require("../Environment"));
-const Dataset_1 = __importDefault(require("../dataset/Dataset"));
-const DatasetRecord_1 = __importDefault(require("../dataset/DatasetRecord"));
-const ConsumerManager_1 = __importDefault(require("../consumer/ConsumerManager"));
-class JoinEngineClass {
-    constructor() {
-        this.validateFieldInProducer = (fieldName, producerName) => {
-            var _a, _b, _c, _d;
-            const producer = Environment_1.default.getProducer(producerName);
-            if (!producer) {
-                throw new Error(`Producer ${producerName} not found`);
-            }
-            // Check dimensions
-            const hasDimension = producer.dimensions.some(d => d.name === fieldName);
-            // Check measures
-            const hasMeasure = (_b = (_a = producer.measures) === null || _a === void 0 ? void 0 : _a.some(m => m.name === fieldName)) !== null && _b !== void 0 ? _b : false;
-            if (!hasDimension && !hasMeasure) {
-                throw new Error(`Field '${fieldName}' not found in producer '${producerName}'. Available fields: ${producer.dimensions.map(d => d.name).concat((_d = (_c = producer.measures) === null || _c === void 0 ? void 0 : _c.map(m => m.name)) !== null && _d !== void 0 ? _d : []).join(', ')}`);
-            }
-        };
-        this.validateFieldInConsumer = (fieldName, consumerShape) => {
-            const hasField = consumerShape.dimensions.find(x => x.name === fieldName);
-            if (!hasField)
-                throw new Error(`Field '${fieldName}' not found in consumer '${consumerShape.name}'. Your join condition must be on fields that are present in the consumer.`);
-        };
-        this.parseJoinCondition = (sql, producer) => {
-            // Extract field names from SQL condition like ${P.id} = ${orders.user_id}
-            const regex = /\${([^}]+)}/g;
-            const matches = Array.from(sql.matchAll(regex));
-            if (matches.length !== 2)
-                throw new Error(`Invalid join condition: ${sql}. Expected format: \${P.field} = \${producer.field}`);
-            const [left, right] = matches.map(m => m[1]);
-            const [leftProducer, leftField] = left.split('.');
-            const [rightProducer, rightField] = right.split('.');
-            if (!leftField || !rightField)
-                throw new Error(`Invalid join condition: ${sql}. Both sides must specify a field name after the dot.`);
-            // Replace P with actual producer name
-            const actualLeftProducer = leftProducer === 'P' ? producer.name : leftProducer;
-            const actualRightProducer = rightProducer === 'P' ? producer.name : rightProducer;
-            // Validate both fields exist in their respective producers
-            this.validateFieldInProducer(leftField, actualLeftProducer);
-            this.validateFieldInProducer(rightField, actualRightProducer);
-            return {
-                leftProducer: actualLeftProducer,
-                leftField: leftField,
-                rightProducer: actualRightProducer,
-                rightField: rightField
-            };
-        };
-        this.findProducerData = (producerName, producedData) => {
-            const data = producedData.find(pd => pd.producerKey === producerName);
-            if (!data)
-                throw new Error(`No data found for producer: ${producerName}`);
-            return data.dataset;
-        };
-        this.createLookupMap = (dataset, key) => __awaiter(this, void 0, void 0, function* () {
-            const map = new Map();
-            yield dataset.streamBatches((batch) => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                for (const record of batch) {
-                    const keyValue = (_a = record.getValue(key)) === null || _a === void 0 ? void 0 : _a.toString();
-                    if (keyValue === undefined)
-                        continue;
-                    const existing = map.get(keyValue);
-                    if (existing) {
-                        existing.push(record);
-                    }
-                    else {
-                        map.set(keyValue, [record]);
-                    }
-                }
-            }));
-            return map;
-        });
-        this.join = (consumer, producedData) => __awaiter(this, void 0, void 0, function* () {
-            (0, Affirm_1.default)(consumer, 'Invalid consumer');
-            (0, Affirm_1.default)(producedData, 'Invalid produced data');
-            if (consumer.producers.length <= 1)
-                return this.findProducerData(consumer.producers[0].name, producedData);
-            if (consumer.producers.some(x => x.union))
-                return yield this.union(consumer, producedData);
-            const consumerShape = ConsumerManager_1.default.getOutputShape(consumer);
-            const consumerColumns = ConsumerManager_1.default.compile(consumer);
-            // Create a new dataset for the joined result
-            const resultDataset = new Dataset_1.default({
-                name: `joined_${consumer.name}`,
-                file: {
-                    fileKey: 'temp',
-                    fileType: 'CSV'
-                },
-                baseProducer: Environment_1.default.getProducer(consumer.producers[0].name),
-                executionId: producedData[0].dataset.getExecutionId()
-            });
-            // Get dimensions for the result dataset based on consumer columns
-            const resultDimensions = consumerColumns.map((col, index) => {
-                var _a, _b;
-                return ({
-                    name: col.consumerAlias || col.consumerKey,
-                    key: col.consumerAlias || col.consumerKey,
-                    index,
-                    type: (_b = (_a = col.dimension) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : 'string',
-                    hidden: null
-                });
-            });
-            // Initialize the result dataset with proper dimensions
-            resultDataset.getDimensions().length = 0;
-            resultDataset.getDimensions().push(...resultDimensions);
-            // Process joins sequentially
-            for (let i = 0; i < consumer.producers.length; i++) {
-                const producer = consumer.producers[i];
-                if (!producer.joins)
-                    continue;
-                for (const join of producer.joins) {
-                    const otherProducer = consumer.producers.find(p => p.name === join.otherName);
-                    if (!otherProducer) {
-                        throw new Error(`Producer ${join.otherName} not found`);
-                    }
-                    const condition = this.parseJoinCondition(join.sql, producer);
-                    this.validateFieldInConsumer(condition.leftField, consumerShape);
-                    this.validateFieldInConsumer(condition.rightField, consumerShape);
-                    const leftDataset = this.findProducerData(condition.leftProducer, producedData);
-                    const rightDataset = this.findProducerData(condition.rightProducer, producedData);
-                    // Create lookup map for the right dataset (smaller dataset)
-                    const rightLookup = yield this.createLookupMap(rightDataset, condition.rightField);
-                    // Perform streaming join
-                    yield this.performStreamingJoin(leftDataset, rightLookup, condition, join.relationship, consumerColumns, resultDataset);
-                }
-            }
-            return resultDataset;
-        });
-        this.union = (consumer, producedData) => __awaiter(this, void 0, void 0, function* () {
-            const getDimensionsKey = (ds) => ds.getDimensions().map(x => x.name.trim()).join(';').trim();
-            const mainDataset = producedData[0].dataset;
-            const mainDimKey = getDimensionsKey(mainDataset);
-            const otherProducedData = producedData.slice(1);
-            for (const prodData of otherProducedData) {
-                const prodDimKey = getDimensionsKey(prodData.dataset);
-                if (mainDimKey !== prodDimKey)
-                    throw new Error(`On consumer "${consumer.name}", can't union the dataset "${prodData.dataset.name}" (producer: ${prodData.producerKey}) because the dimensions are different from the main dataset "${mainDataset.name}" (producer: ${producedData[0].producerKey}). "${mainDimKey}" != "${prodDimKey}"`);
-                yield prodData.dataset.streamBatches((batch) => __awaiter(this, void 0, void 0, function* () {
-                    yield mainDataset.append(batch);
-                }));
-            }
-            return mainDataset;
-        });
-        this.performStreamingJoin = (leftDataset, rightLookup, condition, relationship, consumerColumns, resultDataset) => __awaiter(this, void 0, void 0, function* () {
-            const joinedRecords = [];
-            const batchSize = leftDataset.getBatchSize();
-            yield leftDataset.streamBatches((leftBatch) => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                for (const leftRecord of leftBatch) {
-                    const leftValue = (_a = leftRecord.getValue(condition.leftField)) === null || _a === void 0 ? void 0 : _a.toString();
-                    if (leftValue === undefined)
-                        continue;
-                    const rightRecords = rightLookup.get(leftValue) || [];
-                    if (rightRecords.length === 0) {
-                        // Handle cases where there's no match
-                        if (relationship !== 'one-to-many') {
-                            // For one-to-one and many-to-one, keep rows even without matches
-                            const mergedRecord = this.createMergedRecord(leftRecord, null, condition, consumerColumns, resultDataset);
-                            if (mergedRecord) {
-                                joinedRecords.push(mergedRecord);
-                            }
-                        }
-                        continue;
-                    }
-                    // Create joined records for each match
-                    for (const rightRecord of rightRecords) {
-                        const mergedRecord = this.createMergedRecord(leftRecord, rightRecord, condition, consumerColumns, resultDataset);
-                        if (mergedRecord) {
-                            joinedRecords.push(mergedRecord);
-                        }
-                    }
-                    // Write batch if it's getting large
-                    if (joinedRecords.length >= batchSize) {
-                        yield resultDataset.append(joinedRecords);
-                        joinedRecords.length = 0;
-                    }
-                }
-            }));
-            // Write remaining records
-            if (joinedRecords.length > 0) {
-                yield resultDataset.append(joinedRecords);
-            }
-        });
-        this.createMergedRecord = (leftRecord, rightRecord, condition, consumerColumns, resultDataset) => {
-            const mergedValues = {};
-            // Map each field from the appropriate source
-            for (const column of consumerColumns) {
-                const fieldName = column.consumerAlias || column.consumerKey;
-                if (column.owner === condition.leftProducer) {
-                    // Get value from left dataset
-                    const leftFieldName = column.nameInProducer || fieldName;
-                    mergedValues[fieldName] = leftRecord.getValue(leftFieldName);
-                }
-                else if (column.owner === condition.rightProducer) {
-                    // Get value from right dataset (if exists)
-                    if (rightRecord) {
-                        const rightFieldName = column.nameInProducer || fieldName;
-                        mergedValues[fieldName] = rightRecord.getValue(rightFieldName);
-                    }
-                    else {
-                        mergedValues[fieldName] = null;
-                    }
-                }
-            }
-            // Create the merged record
-            const dimensions = resultDataset.getDimensions();
-            const delimiter = resultDataset.getDelimiter();
-            const values = dimensions.map(dim => mergedValues[dim.name] || '');
-            const recordString = values.join(delimiter);
-            return new DatasetRecord_1.default(recordString, dimensions, delimiter);
-        };
-    }
-}
-const JoinEngine = new JoinEngineClass();
-exports.default = JoinEngine;

package/engines/transform/TransformationEngine.js

@@ -1,277 +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 TypeCaster_1 = __importDefault(require("./TypeCaster"));
-const CryptoEngine_1 = __importDefault(require("../CryptoEngine"));
-const DeveloperEngine_1 = __importDefault(require("../ai/DeveloperEngine"));
-class TransformationEngineClass {
-    constructor() {
-        this.applyTransformations = (value, transformations, field, record) => {
-            var _a;
-            if (Array.isArray(transformations)) {
-                // Process array transformations without creating intermediate arrays
-                let result = value;
-                for (const transform of transformations) {
-                    result = this.applyTransformations(result, transform, field, record);
-                }
-                return result;
-            }
-            // Single transformation
-            if ('cast' in transformations) {
-                const { cast, format } = transformations;
-                const casted = TypeCaster_1.default.cast(value, cast, format);
-                if (cast === 'number' && isNaN(casted))
-                    throw new Error(`Cannot cast non-numeric value in field '${field.key}'`);
-                if (cast === 'datetime' && casted instanceof Date && isNaN(casted.getTime()))
-                    throw new Error(`Cannot cast value to date in field '${field.key}'`);
-                return casted;
-            }
-            if ('multiply' in transformations) {
-                const num = TypeCaster_1.default.cast(value, 'number');
-                if (isNaN(num))
-                    throw new Error(`Cannot multiply non-numeric value in field '${field.key}'`);
-                return num * transformations.multiply;
-            }
-            if ('multiplyBy' in transformations) {
-                if (!record) {
-                    throw new Error(`Cannot apply combine_fields transformation without record context in field '${field.key}'`);
-                }
-                const { fields } = transformations.multiplyBy;
-                const fieldValues = fields.map(fieldName => {
-                    const fieldValue = record[fieldName];
-                    return fieldValue !== null && fieldValue !== undefined ? TypeCaster_1.default.cast(fieldValue, 'number') : 1;
-                });
-                const product = fieldValues.reduce((accumulator, value) => accumulator * value, 1);
-                return product;
-            }
-            if ('add' in transformations) {
-                const num = TypeCaster_1.default.cast(value, 'number');
-                if (isNaN(num))
-                    throw new Error(`Cannot add to non-numeric value in field '${field.key}'`);
-                return num + transformations.add;
-            }
-            if ('addBy' in transformations) {
-                if (!record) {
-                    throw new Error(`Cannot apply combine_fields transformation without record context in field '${field.key}'`);
-                }
-                const { fields } = transformations.addBy;
-                const fieldValues = fields.map(fieldName => {
-                    const fieldValue = record[fieldName];
-                    return fieldValue !== null && fieldValue !== undefined ? TypeCaster_1.default.cast(fieldValue, 'number') : 1;
-                });
-                const sum = fieldValues.reduce((accumulator, value) => accumulator + value);
-                return sum;
-            }
-            if ('extract' in transformations) {
-                const date = TypeCaster_1.default.cast(value, 'date');
-                if (isNaN(date.getTime()))
-                    throw new Error(`Invalid date for extraction in field '${field.key}'`);
-                switch (transformations.extract) {
-                    case 'year': return date.getFullYear();
-                    case 'month': return date.getMonth() + 1; // 1-based month
-                    case 'day': return date.getDate();
-                    case 'hour': return date.getHours();
-                    case 'minute': return date.getMinutes();
-                }
-            }
-            if ('concat' in transformations) {
-                if (!Array.isArray(value))
-                    throw new Error(`Cannot concat non-array value in field '${field.key}'`);
-                return value.join(transformations.concat.separator);
-            }
-            if ('split' in transformations) {
-                if (typeof value !== 'string')
-                    throw new Error(`Cannot split non-string value in field '${field.key}'`);
-                const parts = value.split(transformations.split.separator);
-                if (transformations.split.index >= parts.length) {
-                    throw new Error(`Split index ${transformations.split.index} out of bounds in field '${field.key}'`);
-                }
-                return parts[transformations.split.index];
-            }
-            if ('regex_match' in transformations) {
-                if (typeof value !== 'string')
-                    throw new Error(`Cannot apply regex_match to non-string value in field '${field.key}'`);
-                try {
-                    const regex = new RegExp(transformations.regex_match.pattern, transformations.regex_match.flags);
-                    return regex.test(value);
-                }
-                catch (error) {
-                    throw new Error(`Invalid regex pattern in field '${field.key}': ${error.message}`);
-                }
-            }
-            if ('regex_replace' in transformations) {
-                if (typeof value !== 'string')
-                    throw new Error(`Cannot apply regex_replace to non-string value in field '${field.key}'`);
-                try {
-                    const regex = new RegExp(transformations.regex_replace.pattern, transformations.regex_replace.flags);
-                    return value.replace(regex, transformations.regex_replace.replacement);
-                }
-                catch (error) {
-                    throw new Error(`Invalid regex pattern in field '${field.key}': ${error.message}`);
-                }
-            }
-            if ('regex_extract' in transformations) {
-                if (typeof value !== 'string')
-                    throw new Error(`Cannot apply regex_extract to non-string value in field '${field.key}'`);
-                try {
-                    const regex = new RegExp(transformations.regex_extract.pattern, transformations.regex_extract.flags);
-                    const matches = value.match(regex);
-                    if (!matches)
-                        return null;
-                    const groupIndex = transformations.regex_extract.group;
-                    return (_a = matches[groupIndex]) !== null && _a !== void 0 ? _a : null;
-                }
-                catch (error) {
-                    throw new Error(`Invalid regex pattern in field '${field.key}': ${error.message}`);
-                }
-            }
-            if ('trim' in transformations) {
-                if (typeof value !== 'string')
-                    throw new Error(`Cannot trim non-string value in field '${field.key}'`);
-                return value.trim();
-            }
-            if ('to_lowercase' in transformations) {
-                if (typeof value !== 'string')
-                    throw new Error(`Cannot convert non-string value to lowercase in field '${field.key}'`);
-                return value.toLowerCase();
-            }
-            if ('to_uppercase' in transformations) {
-                if (typeof value !== 'string')
-                    throw new Error(`Cannot convert non-string value to uppercase in field '${field.key}'`);
-                return value.toUpperCase();
-            }
-            if ('capitalize' in transformations) {
-                if (typeof value !== 'string')
-                    throw new Error(`Cannot capitalize non-string value in field '${field.key}'`);
-                return value.charAt(0).toUpperCase() + value.slice(1);
-            }
-            if ('substring' in transformations) {
-                if (!Algo_1.default.hasVal(value))
-                    return '';
-                if (typeof value !== 'string')
-                    throw new Error(`Cannot take substring of non-string value in field '${field.key}'`);
-                const { start, end } = transformations.substring;
-                return end !== undefined ? value.substring(start, end) : value.substring(start);
-            }
-            if ('pad_start' in transformations) {
-                if (typeof value !== 'string')
-                    throw new Error(`Cannot pad non-string value in field '${field.key}'`);
-                const { length, char } = transformations.pad_start;
-                if (char.length !== 1)
-                    throw new Error(`Pad character must be exactly one character in field '${field.key}'`);
-                return value.padStart(length, char);
-            }
-            if ('pad_end' in transformations) {
-                if (typeof value !== 'string')
-                    throw new Error(`Cannot pad non-string value in field '${field.key}'`);
-                const { length, char } = transformations.pad_end;
-                if (char.length !== 1)
-                    throw new Error(`Pad character must be exactly one character in field '${field.key}'`);
-                return value.padEnd(length, char);
-            }
-            if ('prepend' in transformations)
-                return transformations.prepend + TypeCaster_1.default.cast(value, 'string');
-            if ('append' in transformations)
-                return TypeCaster_1.default.cast(value, 'string') + transformations.append;
-            if ('combine_fields' in transformations) {
-                if (!record) {
-                    throw new Error(`Cannot apply combine_fields transformation without record context in field '${field.key}'`);
-                }
-                const { fields, separator = '', template } = transformations.combine_fields;
-                // Get values from the specified fields
-                const fieldValues = fields.map(fieldName => {
-                    const fieldValue = record[fieldName];
-                    return fieldValue !== null && fieldValue !== undefined ? String(fieldValue) : '';
-                });
-                // If template is provided, use it for formatting
-                if (template) {
-                    let result = template;
-                    for (let i = 0; i < fields.length; i++) {
-                        const placeholder = `{${fields[i]}}`;
-                        result = result.replace(new RegExp(placeholder, 'g'), fieldValues[i]);
-                    }
-                    return result;
-                }
-                else {
-                    // Otherwise, join with separator
-                    return fieldValues.join(separator);
-                }
-            }
-            if ('mask' in transformations) {
-                return this.applyMasking(value, transformations.mask, field);
-            }
-            if ('conditional' in transformations) {
-                for (const clause of transformations.conditional.clauses) {
-                    if (this.evaluateCondition(value, clause.if)) {
-                        return clause.then;
-                    }
-                }
-                return transformations.conditional.else !== undefined ? transformations.conditional.else : value;
-            }
-            return value;
-        };
-        this.evaluateCondition = (value, condition) => {
-            if ('greater_than' in condition) {
-                return TypeCaster_1.default.cast(value, 'number') > condition.greater_than;
-            }
-            if ('greater_than_or_equal' in condition) {
-                return TypeCaster_1.default.cast(value, 'number') >= condition.greater_than_or_equal;
-            }
-            if ('less_than' in condition) {
-                return TypeCaster_1.default.cast(value, 'number') < condition.less_than;
-            }
-            if ('less_than_or_equal' in condition) {
-                return TypeCaster_1.default.cast(value, 'number') <= condition.less_than_or_equal;
-            }
-            if ('equals' in condition) {
-                return value === condition.equals;
-            }
-            if ('not_equals' in condition) {
-                return value !== condition.not_equals;
-            }
-            if ('in' in condition) {
-                return condition.in.includes(value);
-            }
-            if ('not_in' in condition) {
-                return !condition.not_in.includes(value);
-            }
-            if ('starts_with' in condition) {
-                return TypeCaster_1.default.cast(value, 'string').startsWith(condition.starts_with);
-            }
-            if ('ends_with' in condition) {
-                return TypeCaster_1.default.cast(value, 'string').endsWith(condition.ends_with);
-            }
-            if ('contains' in condition) {
-                return TypeCaster_1.default.cast(value, 'string').includes(condition.contains);
-            }
-            if ('not_contains' in condition) {
-                return !TypeCaster_1.default.cast(value, 'string').includes(condition.not_contains);
-            }
-            if ('is_empty' in condition) {
-                return value === null || value === undefined || TypeCaster_1.default.cast(value, 'string').trim() === '';
-            }
-            if ('is_not_empty' in condition) {
-                return value !== null && value !== undefined && TypeCaster_1.default.cast(value, 'string').trim() !== '';
-            }
-            return false;
-        };
-        this.applyMasking = (value, maskType, field) => {
-            if (!Algo_1.default.hasVal(value))
-                return value;
-            if (maskType === 'none')
-                return value;
-            const valueType = DeveloperEngine_1.default.inferDimensionType(value);
-            try {
-                return CryptoEngine_1.default.hashValue(maskType, String(value), valueType);
-            }
-            catch (error) {
-                throw new Error(`Failed to apply masking transformation '${maskType}' to field '${field.key}': ${error.message}`);
-            }
-        };
-    }
-}
-const TransformationEngine = new TransformationEngineClass();
-exports.default = TransformationEngine;

package/engines/transform/TypeCaster.js

@@ -1,59 +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 dayjs_1 = __importDefault(require("dayjs"));
-const customParseFormat_1 = __importDefault(require("dayjs/plugin/customParseFormat"));
-const utc_1 = __importDefault(require("dayjs/plugin/utc"));
-dayjs_1.default.extend(customParseFormat_1.default);
-dayjs_1.default.extend(utc_1.default);
-class TypeCasterClass {
-    /**
-     * Casts the value to the requested type (only if needed)
-     * Optional format parameter currently supports:
-     *  - Parsing dates (type 'date'/'datetime') from string with tokens: yyyy, mm, dd
-     *  - Formatting dates when casting to string with same tokens
-     */
-    cast(value, type, format) {
-        if (!Algo_1.default.hasVal(value))
-            return value;
-        switch (type) {
-            case 'boolean': {
-                if (typeof value === 'boolean')
-                    return value;
-                return Boolean(value);
-            }
-            case 'datetime':
-            case 'date': {
-                let dateValue = null;
-                try {
-                    if (format && typeof value === 'string')
-                        dateValue = dayjs_1.default.utc(value, format, true).toDate();
-                    else
-                        dateValue = new Date(value);
-                    return dateValue.toISOString();
-                }
-                catch (error) {
-                    dateValue = new Date(value);
-                    if (!isNaN(dateValue))
-                        return dateValue.toISOString();
-                    throw new Error(`Error casting "${value}" to date with format "${format}": ${error}`);
-                }
-            }
-            case 'number': {
-                if (typeof value === 'number')
-                    return value;
-                return Number(value);
-            }
-            case 'string': {
-                if (typeof value === 'string')
-                    return value;
-                return String(value);
-            }
-        }
-    }
-}
-const TypeCaster = new TypeCasterClass();
-exports.default = TypeCaster;

package/engines/usage/DataframeManager.js

@@ -1,55 +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 Helper_1 = __importDefault(require("../../helper/Helper"));
-class DataframeManagerClass {
-    fill(points, from, to, onlyLastValue, maintainLastValue) {
-        const min = from !== null && from !== void 0 ? from : this.getMinDate(points);
-        const max = to !== null && to !== void 0 ? to : this.getMaxDate(points);
-        const orderPoints = points.length > 0 ? Algo_1.default.orderBy(points, 'x') : [];
-        const filledPoints = [];
-        const currentDate = new Date(min);
-        while (currentDate <= max) {
-            const monthKey = Helper_1.default.formatDateToYYYYMM(currentDate);
-            filledPoints.push({ x: monthKey, y: 0 });
-            currentDate.setMonth(currentDate.getMonth() + 1);
-        }
-        for (let i = 0; i < orderPoints.length; i++) {
-            const point = orderPoints[i];
-            const date = new Date(point.x);
-            const filledPoint = filledPoints.find(x => x.x === Helper_1.default.formatDateToYYYYMM(date));
-            if (filledPoint) {
-                if (!onlyLastValue)
-                    filledPoint.y += point.y;
-                else
-                    filledPoint.y = point.y;
-                if (maintainLastValue) {
-                    const index = filledPoints.findIndex(x => x.x === Helper_1.default.formatDateToYYYYMM(date));
-                    for (let k = index; k < filledPoints.length; k++) {
-                        const nextFilledPoint = filledPoints[k];
-                        nextFilledPoint.y = filledPoint.y;
-                    }
-                }
-            }
-        }
-        return filledPoints;
-    }
-    getMinDate(points) {
-        if (!points || points.length === 0) {
-            const currentDate = new Date();
-            return new Date(currentDate.getFullYear() - 1, currentDate.getMonth(), currentDate.getDate());
-        }
-        return points.reduce((min, point) => (new Date(point.x) < min ? new Date(point === null || point === void 0 ? void 0 : point.x) : min), new Date(points[0].x));
-    }
-    getMaxDate(points) {
-        if (!points || points.length === 0) {
-            return new Date();
-        }
-        return points.reduce((max, point) => (new Date(point.x) > max ? new Date(point.x) : max), new Date(points[0].x));
-    }
-}
-const DataframeManager = new DataframeManagerClass();
-exports.default = DataframeManager;