datamodel/src/datamodel.js

/* eslint-disable default-case */

import { FieldType, DimensionSubtype, DataFormat, FilteringMode } from './enums';
import {
    persistDerivations,
    getRootGroupByModel,
    propagateToAllDataModels,
    getRootDataModel,
    propagateImmutableActions,
    addToPropNamespace,
    sanitizeUnitSchema,
    splitWithSelect,
    splitWithProject,
    getNormalizedProFields
} from './helper';
import { DM_DERIVATIVES, PROPAGATION } from './constants';
import {
    dataBuilder,
    rowDiffsetIterator,
    groupBy
} from './operator';
import { createBinnedFieldData } from './operator/bucket-creator';
import Relation from './relation';
import reducerStore from './utils/reducer-store';
import { createFields } from './field-creator';
import InvalidAwareTypes from './invalid-aware-types';
import Value from './value';

/**
 * DataModel is an in-browser representation of tabular data. It supports
 * {@link https://en.wikipedia.org/wiki/Relational_algebra | relational algebra} operators as well as generic data
 * processing opearators.
 * DataModel extends {@link Relation} class which defines all the relational algebra opreators. DataModel gives
 * definition of generic data processing operators which are not relational algebra complient.
 *
 * @public
 * @class
 * @extends Relation
 * @memberof Datamodel
 */
class DataModel extends Relation {
    /**
     * Creates a new DataModel instance by providing data and schema. Data could be in the form of
     * - Flat JSON
     * - DSV String
     * - 2D Array
     *
     * By default DataModel finds suitable adapter to serialize the data. DataModel also expects a
     * {@link Schema | schema} for identifying the variables present in data.
     *
     * @constructor
     * @example
     * const data = loadData('cars.csv');
     * const schema = [
     *      { name: 'Name', type: 'dimension' },
     *      { name: 'Miles_per_Gallon', type: 'measure', unit : 'cm', scale: '1000', numberformat: val => `${val}G`},
     *      { name: 'Cylinders', type: 'dimension' },
     *      { name: 'Displacement', type: 'measure' },
     *      { name: 'Horsepower', type: 'measure' },
     *      { name: 'Weight_in_lbs', type: 'measure' },
     *      { name: 'Acceleration', type: 'measure' },
     *      { name: 'Year', type: 'dimension', subtype: 'datetime', format: '%Y' },
     *      { name: 'Origin', type: 'dimension' }
     * ];
     * const dm = new DataModel(data, schema, { name: 'Cars' });
     * table(dm);
     *
     * @public
     *
     * @param {Array.<Object> | string | Array.<Array>} data Input data in any of the mentioned formats
     * @param {Array.<Schema>} schema Defination of the variables. Order of the variables in data and order of the
     *      variables in schema has to be same.
     * @param {object} [options] Optional arguments to specify more settings regarding the creation part
     * @param {string} [options.name] Name of the datamodel instance. If no name is given an auto generated name is
     *      assigned to the instance.
     * @param {string} [options.fieldSeparator=','] specify field separator type if the data is of type dsv string.
     */
    constructor (...args) {
        super(...args);

        this._onPropagation = [];
    }

    /**
     * Reducers are simple functions which reduces an array of numbers to a representative number of the set.
     * Like an array of numbers `[10, 20, 5, 15]` can be reduced to `12.5` if average / mean reducer function is
     * applied. All the measure fields in datamodel (variables in data) needs a reducer to handle aggregation.
     *
     * @public
     *
     * @return {ReducerStore} Singleton instance of {@link ReducerStore}.
     */
    static get Reducers () {
        return reducerStore;
    }

    /**
     * Configure null, undefined, invalid values in the source data
     *
     * @public
     *
     * @param {Object} [config] - Configuration to control how null, undefined and non-parsable values are
     * represented in DataModel.
     * @param {string} [config.undefined] - Define how an undefined value will be represented.
     * @param {string} [config.null] - Define how a null value will be represented.
     * @param {string} [config.invalid] - Define how a non-parsable value will be represented.
     */
    static configureInvalidAwareTypes (config) {
        return InvalidAwareTypes.invalidAwareVals(config);
    }

    /**
     * Retrieve the data attached to an instance in JSON format.
     *
     * @example
     * // DataModel instance is already prepared and assigned to dm variable
     *  const data = dm.getData({
     *      order: 'column',
     *      formatter: {
     *          origin: (val) => val === 'European Union' ? 'EU' : val;
     *      }
     *  });
     *  console.log(data);
     *
     * @public
     *
     * @param {Object} [options] Options to control how the raw data is to be returned.
     * @param {string} [options.order='row'] Defines if data is retieved in row order or column order. Possible values
     *      are `'rows'` and `'columns'`
     * @param {Function} [options.formatter=null] Formats the output data. This expects an object, where the keys are
     *      the name of the variable needs to be formatted. The formatter function is called for each row passing the
     *      value of the cell for a particular row as arguments. The formatter is a function in the form of
     *      `function (value, rowId, schema) => { ... }`
     *      Know more about {@link Fomatter}.
     *
     * @return {Array} Returns a multidimensional array of the data with schema. The return format looks like
     *      ```
     *          {
     *              data,
     *              schema
     *          }
     *      ```
     */
    getData (options) {
        const defOptions = {
            order: 'row',
            formatter: null,
            withUid: false,
            getAllFields: false,
            sort: []
        };
        options = Object.assign({}, defOptions, options);
        const fields = this.getPartialFieldspace().fields;

        const dataGenerated = dataBuilder.call(
            this,
            this.getPartialFieldspace().fields,
            this._rowDiffset,
            options.getAllFields ? fields.map(d => d.name()).join() : this._colIdentifier,
            options.sort,
            {
                columnWise: options.order === 'column',
                addUid: !!options.withUid
            }
        );

        if (!options.formatter) {
            return dataGenerated;
        }

        const { formatter } = options;
        const { data, schema, uids } = dataGenerated;
        const fieldNames = schema.map((e => e.name));
        const fmtFieldNames = Object.keys(formatter);
        const fmtFieldIdx = fmtFieldNames.reduce((acc, next) => {
            const idx = fieldNames.indexOf(next);
            if (idx !== -1) {
                acc.push([idx, formatter[next]]);
            }
            return acc;
        }, []);

        if (options.order === 'column') {
            fmtFieldIdx.forEach((elem) => {
                const fIdx = elem[0];
                const fmtFn = elem[1];

                data[fIdx].forEach((datum, datumIdx) => {
                    data[fIdx][datumIdx] = fmtFn.call(
                        undefined,
                        datum,
                        uids[datumIdx],
                        schema[fIdx]
                    );
                });
            });
        } else {
            data.forEach((datum, datumIdx) => {
                fmtFieldIdx.forEach((elem) => {
                    const fIdx = elem[0];
                    const fmtFn = elem[1];

                    datum[fIdx] = fmtFn.call(
                        undefined,
                        datum[fIdx],
                        uids[datumIdx],
                        schema[fIdx]
                    );
                });
            });
        }

        return dataGenerated;
    }

    /**
     * Returns the unique ids in an array.
     *
     * @return {Array} Returns an array of ids.
     */
    getUids () {
        const rowDiffset = this._rowDiffset;
        const ids = [];

        if (rowDiffset.length) {
            const diffSets = rowDiffset.split(',');

            diffSets.forEach((set) => {
                let [start, end] = set.split('-').map(Number);

                end = end !== undefined ? end : start;
                ids.push(...Array(end - start + 1).fill().map((_, idx) => start + idx));
            });
        }

        return ids;
    }
    /**
     * Groups the data using particular dimensions and by reducing measures. It expects a list of dimensions using which
     * it projects the datamodel and perform aggregations to reduce the duplicate tuples. Refer this
     * {@link link_to_one_example_with_group_by | document} to know the intuition behind groupBy.
     *
     * DataModel by default provides definition of few {@link reducer | Reducers}.
     * {@link ReducerStore | User defined reducers} can also be registered.
     *
     * This is the chained implementation of `groupBy`.
     * `groupBy` also supports {@link link_to_compose_groupBy | composability}
     *
     * @example
     * const groupedDM = dm.groupBy(['Year'], { horsepower: 'max' } );
     * console.log(groupedDm);
     *
     * @public
     *
     * @param {Array.<string>} fieldsArr - Array containing the name of dimensions
     * @param {Object} [reducers={}] - A map whose key is the variable name and value is the name of the reducer. If its
     *      not passed, or any variable is ommitted from the object, default aggregation function is used from the
     *      schema of the variable.
     *
     * @return {DataModel} Returns a new DataModel instance after performing the groupby.
     */
    groupBy (fieldsArr, reducers = {}, config = { saveChild: true }) {
        const groupByString = `${fieldsArr.join()}`;
        let params = [this, fieldsArr, reducers];
        const newDataModel = groupBy(...params);

        persistDerivations(
            this,
            newDataModel,
            DM_DERIVATIVES.GROUPBY,
            { fieldsArr, groupByString, defaultReducer: reducerStore.defaultReducer() },
            reducers
        );

        if (config.saveChild) {
            newDataModel.setParent(this);
        } else {
            newDataModel.setParent(null);
        }

        return newDataModel;
    }

    /**
     * Performs sorting operation on the current {@link DataModel} instance according to the specified sorting details.
     * Like every other operator it doesn't mutate the current DataModel instance on which it was called, instead
     * returns a new DataModel instance containing the sorted data.
     *
     * DataModel support multi level sorting by listing the variables using which sorting needs to be performed and
     * the type of sorting `ASC` or `DESC`.
     *
     * In the following example, data is sorted by `Origin` field in `DESC` order in first level followed by another
     * level of sorting by `Acceleration` in `ASC` order.
     *
     * @example
     * // here dm is the pre-declared DataModel instance containing the data of 'cars.json' file
     * let sortedDm = dm.sort([
     *    ["Origin", "DESC"]
     *    ["Acceleration"] // Default value is ASC
     * ]);
     *
     * console.log(dm.getData());
     * console.log(sortedDm.getData());
     *
     * // Sort with a custom sorting function
     * sortedDm = dm.sort([
     *    ["Origin", "DESC"]
     *    ["Acceleration", (a, b) => a - b] // Custom sorting function
     * ]);
     *
     * console.log(dm.getData());
     * console.log(sortedDm.getData());
     *
     * @text
     * DataModel also provides another sorting mechanism out of the box where sort is applied to a variable using
     * another variable which determines the order.
     * Like the above DataModel contains three fields `Origin`, `Name` and `Acceleration`. Now, the data in this
     * model can be sorted by `Origin` field according to the average value of all `Acceleration` for a
     * particular `Origin` value.
     *
     * @example
     * // here dm is the pre-declared DataModel instance containing the data of 'cars.json' file
     * const sortedDm = dm.sort([
     *     ['Origin', ['Acceleration', (a, b) => avg(...a.Acceleration) - avg(...b.Acceleration)]]
     * ]);
     *
     * console.log(dm.getData());
     * console.log(sortedDm.getData());
     *
     * @public
     *
     * @param {Array.<Array>} sortingDetails - Sorting details based on which the sorting will be performed.
     * @return {DataModel} Returns a new instance of DataModel with sorted data.
     */
    sort (sortingDetails, config = { saveChild: false }) {
        const rawData = this.getData({
            order: 'row',
            sort: sortingDetails
        });
        const header = rawData.schema.map(field => field.name);
        const dataInCSVArr = [header].concat(rawData.data);

        const sortedDm = new this.constructor(dataInCSVArr, rawData.schema, { dataFormat: 'DSVArr' });

        persistDerivations(
            this,
            sortedDm,
            DM_DERIVATIVES.SORT,
            config,
            sortingDetails
        );

        if (config.saveChild) {
            sortedDm.setParent(this);
        } else {
            sortedDm.setParent(null);
        }

        return sortedDm;
    }

    /**
     * Performs the serialization operation on the current {@link DataModel} instance according to the specified data
     * type. When an {@link DataModel} instance is created, it de-serializes the input data into its internal format,
     * and during its serialization process, it converts its internal data format to the specified data type and returns
     * that data regardless what type of data is used during the {@link DataModel} initialization.
     *
     * @example
     * // here dm is the pre-declared DataModel instance.
     * const csvData = dm.serialize(DataModel.DataFormat.DSV_STR, { fieldSeparator: "," });
     * console.log(csvData); // The csv formatted data.
     *
     * const jsonData = dm.serialize(DataModel.DataFormat.FLAT_JSON);
     * console.log(jsonData); // The json data.
     *
     * @public
     *
     * @param {string} type - The data type name for serialization.
     * @param {Object} options - The optional option object.
     * @param {string} options.fieldSeparator - The field separator character for DSV data type.
     * @return {Array|string} Returns the serialized data.
     */
    serialize (type, options) {
        type = type || this._dataFormat;
        options = Object.assign({}, { fieldSeparator: ',' }, options);

        const fields = this.getFieldspace().fields;
        const colData = fields.map(f => f.formattedData());
        const rowsCount = colData[0].length;
        let serializedData;
        let rowIdx;
        let colIdx;

        if (type === DataFormat.FLAT_JSON) {
            serializedData = [];
            for (rowIdx = 0; rowIdx < rowsCount; rowIdx++) {
                const row = {};
                for (colIdx = 0; colIdx < fields.length; colIdx++) {
                    row[fields[colIdx].name()] = colData[colIdx][rowIdx];
                }
                serializedData.push(row);
            }
        } else if (type === DataFormat.DSV_STR) {
            serializedData = [fields.map(f => f.name()).join(options.fieldSeparator)];
            for (rowIdx = 0; rowIdx < rowsCount; rowIdx++) {
                const row = [];
                for (colIdx = 0; colIdx < fields.length; colIdx++) {
                    row.push(colData[colIdx][rowIdx]);
                }
                serializedData.push(row.join(options.fieldSeparator));
            }
            serializedData = serializedData.join('\n');
        } else if (type === DataFormat.DSV_ARR) {
            serializedData = [fields.map(f => f.name())];
            for (rowIdx = 0; rowIdx < rowsCount; rowIdx++) {
                const row = [];
                for (colIdx = 0; colIdx < fields.length; colIdx++) {
                    row.push(colData[colIdx][rowIdx]);
                }
                serializedData.push(row);
            }
        } else {
            throw new Error(`Data type ${type} is not supported`);
        }

        return serializedData;
    }

    addField (field) {
        const fieldName = field.name();
        this._colIdentifier += `,${fieldName}`;
        const partialFieldspace = this._partialFieldspace;
        const cachedValueObjects = partialFieldspace._cachedValueObjects;
        const formattedData = field.formattedData();
        const rawData = field.partialField.data;

        if (!partialFieldspace.fieldsObj()[field.name()]) {
            partialFieldspace.fields.push(field);
            cachedValueObjects.forEach((obj, i) => {
                obj[field.name()] = new Value(formattedData[i], rawData[i], field);
            });
        } else {
            const fieldIndex = partialFieldspace.fields.findIndex(fieldinst => fieldinst.name() === fieldName);
            fieldIndex >= 0 && (partialFieldspace.fields[fieldIndex] = field);
        }

        // flush out cached namespace values on addition of new fields
        partialFieldspace._cachedFieldsObj = null;
        partialFieldspace._cachedDimension = null;
        partialFieldspace._cachedMeasure = null;

        this.__calculateFieldspace().calculateFieldsConfig();
        return this;
    }

    /**
    * Creates a new variable calculated from existing variables. This method expects the definition of the newly created
    * variable and a function which resolves the value of the new variable from existing variables.
    *
    * Can create a new measure based on existing variables:
    * @example
    *  // DataModel already prepared and assigned to dm variable;
    *  const newDm = dataModel.calculateVariable({
    *      name: 'powerToWeight',
    *      type: 'measure'
    *  }, ['horsepower', 'weight_in_lbs', (hp, weight) => hp / weight ]);
    *
    *
    * Can create a new dimension based on existing variables:
    * @example
    *  // DataModel already prepared and assigned to dm variable;
    *  const child = dataModel.calculateVariable(
    *     {
    *       name: 'Efficiency',
    *       type: 'dimension'
    *     }, ['horsepower', (hp) => {
    *      if (hp < 80) { return 'low'; },
    *      else if (hp < 120) { return 'moderate'; }
    *      else { return 'high' }
    *  }]);
    *
    * @public
    *
    * @param {Object} schema - The schema of newly defined variable.
    * @param {Array.<string|function>} dependency - An array containing the dependency variable names and a resolver
    * function as the last element.
    * @param {Object} config - An optional config object.
    * @param {boolean} [config.saveChild] - Whether the newly created DataModel will be a child.
    * @param {boolean} [config.replaceVar] - Whether the newly created variable will replace the existing variable.
    * @return {DataModel} Returns an instance of DataModel with the new field.
    */
    calculateVariable (schema, dependency, config) {
        schema = sanitizeUnitSchema(schema);
        config = Object.assign({}, { saveChild: true, replaceVar: false }, config);

        const fieldsConfig = this.getFieldsConfig();
        const depVars = dependency.slice(0, dependency.length - 1);
        const retrieveFn = dependency[dependency.length - 1];

        if (fieldsConfig[schema.name] && !config.replaceVar) {
            throw new Error(`${schema.name} field already exists in datamodel`);
        }

        const depFieldIndices = depVars.map((field) => {
            const fieldSpec = fieldsConfig[field];
            if (!fieldSpec) {
                // @todo dont throw error here, use warning in production mode
                throw new Error(`${field} is not a valid column name.`);
            }
            return fieldSpec.index;
        });

        const clone = this.clone(config.saveChild);

        const fs = clone.getFieldspace().fields;
        const suppliedFields = depFieldIndices.map(idx => fs[idx]);

        let cachedStore = {};
        let cloneProvider = () => this.detachedRoot();

        const computedValues = [];
        rowDiffsetIterator(clone._rowDiffset, (i) => {
            const fieldsData = suppliedFields.map(field => field.partialField.data[i]);
            computedValues[i] = retrieveFn(...fieldsData, i, cloneProvider, cachedStore);
        });
        const [field] = createFields([computedValues], [schema], [schema.name]);
        clone.addField(field);

        persistDerivations(
            this,
            clone,
            DM_DERIVATIVES.CAL_VAR,
            { config: schema, fields: depVars },
            retrieveFn
        );

        return clone;
    }

    /**
     * Propagates changes across all the connected DataModel instances.
     *
     * @param {Array} identifiers - A list of identifiers that were interacted with.
     * @param {Object} payload - The interaction specific details.
     *
     * @return {DataModel} DataModel instance.
     */
    propagate (identifiers, config = {}, addToNameSpace, propConfig = {}) {
        const isMutableAction = config.isMutableAction;
        const propagationSourceId = config.sourceId;
        const payload = config.payload;
        const rootModel = getRootDataModel(this);
        const propagationNameSpace = rootModel._propagationNameSpace;
        const rootGroupByModel = getRootGroupByModel(this);
        const rootModels = {
            groupByModel: rootGroupByModel,
            model: rootModel
        };

        addToNameSpace && addToPropNamespace(propagationNameSpace, config, this);
        propagateToAllDataModels(identifiers, rootModels, { propagationNameSpace, sourceId: propagationSourceId },
            Object.assign({
                payload
            }, config));

        if (isMutableAction) {
            propagateImmutableActions(propagationNameSpace, rootModels, {
                config,
                propConfig
            }, this);
        }

        return this;
    }

    /**
     * Associates a callback with an event name.
     *
     * @param {string} eventName - The name of the event.
     * @param {Function} callback - The callback to invoke.
     * @return {DataModel} Returns this current DataModel instance itself.
     */
    on (eventName, callback) {
        switch (eventName) {
        case PROPAGATION:
            this._onPropagation.push(callback);
            break;
        }
        return this;
    }

    /**
     * Unsubscribes the callbacks for the provided event name.
     *
     * @param {string} eventName - The name of the event to unsubscribe.
     * @return {DataModel} Returns the current DataModel instance itself.
     */
    unsubscribe (eventName) {
        switch (eventName) {
        case PROPAGATION:
            this._onPropagation = [];
            break;

        }
        return this;
    }

    /**
     * This method is used to invoke the method associated with propagation.
     *
     * @param {Object} payload The interaction payload.
     * @param {DataModel} identifiers The propagated DataModel.
     * @memberof DataModel
     */
    handlePropagation (propModel, payload) {
        let propListeners = this._onPropagation;
        propListeners.forEach(fn => fn.call(this, propModel, payload));
    }

    /**
     * Performs the binning operation on a measure field based on the binning configuration. Binning means discretizing
     * values of a measure. Binning configuration contains an array; subsequent values from the array marks the boundary
     * of buckets in [inclusive, exclusive) range format. This operation does not mutate the subject measure field,
     * instead, it creates a new field (variable) of type dimension and subtype binned.
     *
     * Binning can be configured by
     * - providing custom bin configuration with non-uniform buckets,
     * - providing bins count,
     * - providing each bin size,
     *
     * When custom `buckets` are provided as part of binning configuration:
     * @example
     *  // DataModel already prepared and assigned to dm variable
     *  const config = { name: 'binnedHP', buckets: [30, 80, 100, 110] }
     *  const binnedDM = dataModel.bin('horsepower', config);
     *
     * @text
     * When `binsCount` is defined as part of binning configuration:
     * @example
     *  // DataModel already prepared and assigned to dm variable
     *  const config = { name: 'binnedHP', binsCount: 5, start: 0, end: 100 }
     *  const binDM = dataModel.bin('horsepower', config);
     *
     * @text
     * When `binSize` is defined as part of binning configuration:
     * @example
     *  // DataModel already prepared and assigned to dm variable
     *  const config = { name: 'binnedHorsepower', binSize: 20, start: 5}
     *  const binDM = dataModel.bin('horsepower', config);
     *
     * @public
     *
     * @param {string} measureFieldName - The name of the target measure field.
     * @param {Object} config - The config object.
     * @param {string} [config.name] - The name of the new field which will be created.
     * @param {string} [config.buckets] - An array containing the bucket ranges.
     * @param {string} [config.binSize] - The size of each bin. It is ignored when buckets are given.
     * @param {string} [config.binsCount] - The total number of bins to generate. It is ignored when buckets are given.
     * @param {string} [config.start] - The start value of the bucket ranges. It is ignored when buckets are given.
     * @param {string} [config.end] - The end value of the bucket ranges. It is ignored when buckets are given.
     * @return {DataModel} Returns a new {@link DataModel} instance with the new field.
     */
    bin (measureFieldName, config) {
        const fieldsConfig = this.getFieldsConfig();

        if (!fieldsConfig[measureFieldName]) {
            throw new Error(`Field ${measureFieldName} doesn't exist`);
        }

        const binFieldName = config.name || `${measureFieldName}_binned`;

        if (fieldsConfig[binFieldName]) {
            throw new Error(`Field ${binFieldName} already exists`);
        }

        const measureField = this.getFieldspace().fieldsObj()[measureFieldName];
        const { binnedData, bins } = createBinnedFieldData(measureField, this._rowDiffset, config);

        const binField = createFields([binnedData], [
            {
                name: binFieldName,
                type: FieldType.DIMENSION,
                subtype: DimensionSubtype.BINNED,
                bins
            }], [binFieldName])[0];

        const clone = this.clone(config.saveChild);
        clone.addField(binField);

        persistDerivations(
            this,
            clone,
            DM_DERIVATIVES.BIN,
             { measureFieldName, config, binFieldName },
             null
        );

        return clone;
    }

    /**
     * Creates a new {@link DataModel} instance with completely detached root from current {@link DataModel} instance,
     * the new {@link DataModel} instance has no parent-children relationship with the current one, but has same data as
     * the current one.
     * This API is useful when a completely different {@link DataModel} but with same data as the current instance is
     * needed.
     *
     * @example
     *  const dm = new DataModel(data, schema);
     *  const detachedDm = dm.detachedRoot();
     *
     * // has different namespace
     * console.log(dm.getPartialFieldspace().name);
     * console.log(detachedDm.getPartialFieldspace().name);
     *
     * // has same data
     * console.log(dm.getData());
     * console.log(detachedDm.getData());
     *
     * @public
     *
     * @return {DataModel} Returns a detached {@link DataModel} instance.
     */
    detachedRoot () {
        const data = this.serialize(DataFormat.FLAT_JSON);
        const schema = this.getSchema();

        return new DataModel(data, schema);
    }

    /**
     * Creates a set of new {@link DataModel} instances by splitting the set of rows in the source {@link DataModel}
     * instance based on a set of dimensions.
     *
     * For each unique dimensional value, a new split is created which creates a unique {@link DataModel} instance for
     *  that split
     *
     * If multiple dimensions are provided, it splits the source {@link DataModel} instance with all possible
     * combinations of the dimensional values for all the dimensions provided
     *
     * Additionally, it also accepts a predicate function to reduce the set of rows provided. A
     * {@link link_to_selection | Selection} is performed on all the split {@link DataModel} instances based on
     * the predicate function
     *
     * @example
     *  // without predicate function:
     *  const splitDt = dt.splitByRow(['Origin'])
     *  console.log(splitDt));
     * // This should give three unique DataModel instances, one each having rows only for 'USA',
     * // 'Europe' and 'Japan' respectively
     *
     * @example
     *  // without predicate function:
     *  const splitDtMulti = dt.splitByRow(['Origin', 'Cylinders'])
     *  console.log(splitDtMulti));
     * // This should give DataModel instances for all unique combinations of Origin and Cylinder values
     *
     * @example
     * // with predicate function:
     * const splitWithPredDt = dt.select(['Origin'], fields => fields.Origin.value === "USA")
     * console.log(splitWithPredDt);
     * // This should not include the DataModel for the Origin : 'USA'
     *
     *
     * @public
     *
     * @param {Array} dimensionArr - Set of dimensions based on which the split should occur
     * @param {Object} config - The configuration object
     * @param {string} [config.saveChild] - Configuration to save child or not
     * @param {string}[config.mode=FilteringMode.NORMAL] -The mode of the selection.
     * @return {Array}  Returns the new DataModel instances after operation.
     */
    splitByRow (dimensionArr, reducerFn, config) {
        const fieldsConfig = this.getFieldsConfig();

        dimensionArr.forEach((fieldName) => {
            if (!fieldsConfig[fieldName]) {
                throw new Error(`Field ${fieldName} doesn't exist in the schema`);
            }
        });

        const defConfig = {
            mode: FilteringMode.NORMAL,
            saveChild: true
        };

        config = Object.assign({}, defConfig, config);

        return splitWithSelect(this, dimensionArr, reducerFn, config);
    }

    /**
     * Creates a set of new {@link DataModel} instances by splitting the set of fields in the source {@link DataModel}
     * instance based on a set of common and unique field names provided.
     *
     * Each DataModel created contains a set of fields which are common to all and a set of unique fields.
     * It also accepts configurations such as saveChild and mode(inverse or normal) to include/exclude the respective
     * fields
     *
     * @example
     *  // without predicate function:
     *  const splitDt = dt.splitByColumn( [['Acceleration'], ['Horsepower']], ['Origin'])
     *  console.log(splitDt));
     * // This should give two unique DataModel instances, both having the field 'Origin' and
     * // one each having 'Acceleration' and 'Horsepower' fields respectively
     *
     * @example
     *  // without predicate function:
     *  const splitDtInv = dt.splitByColumn( [['Acceleration'], ['Horsepower'],['Origin', 'Cylinders'],
     *                           {mode: 'inverse'})
     *  console.log(splitDtInv));
     * // This should give DataModel instances in the following way:
     * // All DataModel Instances do not have the fields 'Origin' and 'Cylinders'
     * // One DataModel Instance has rest of the fields except 'Acceleration' and the other DataModel instance
     * // has rest of the fields except 'Horsepower'
     *
     *
     *
     * @public
     *
     * @param {Array} uniqueFields - Set of unique fields included in each datamModel instance
     * @param {Array} commonFields - Set of common fields included in all datamModel instances
     * @param {Object} config - The configuration object
     * @param {string} [config.saveChild] - Configuration to save child or not
     * @param {string}[config.mode=FilteringMode.NORMAL] -The mode of the selection.
     * @return {Array}  Returns the new DataModel instances after operation.
     */
    splitByColumn (uniqueFields = [], commonFields = [], config) {
        const defConfig = {
            mode: FilteringMode.NORMAL,
            saveChild: true
        };
        const fieldConfig = this.getFieldsConfig();
        const allFields = Object.keys(fieldConfig);
        const normalizedProjFieldSets = [[commonFields]];

        config = Object.assign({}, defConfig, config);
        uniqueFields = uniqueFields.length ? uniqueFields : [[]];


        uniqueFields.forEach((fieldSet, i) => {
            normalizedProjFieldSets[i] = getNormalizedProFields(
                [...fieldSet, ...commonFields],
                allFields,
                fieldConfig);
        });

        return splitWithProject(this, normalizedProjFieldSets, config, allFields);
    }


}

export default DataModel;