dbgate-datalib 6.4.3-alpha.1 → 6.5.0

package/lib/FreeTableGridDisplay.d.ts

@@ -32,6 +32,7 @@ export declare class FreeTableGridDisplay extends GridDisplay {
         options?: [];
         canSelectMultipleOptions?: boolean;
         undropColumnName?: string;
+        hasAutoValue?: boolean;
         contentHash?: string;
         engine?: string;
     }[];
@@ -61,6 +62,7 @@ export declare class FreeTableGridDisplay extends GridDisplay {
         options?: [];
         canSelectMultipleOptions?: boolean;
         undropColumnName?: string;
+        hasAutoValue?: boolean;
         contentHash?: string;
         engine?: string;
     };

package/lib/GridDisplay.d.ts

@@ -12,6 +12,7 @@ export interface DisplayColumn {
     notNull?: boolean;
     autoIncrement?: boolean;
     isPrimaryKey?: boolean;
+    hasAutoValue?: boolean;
     isPartitionKey?: boolean;
     isClusterKey?: boolean;
     isUniqueKey?: boolean;
@@ -40,7 +41,8 @@ export declare abstract class GridDisplay {
     driver?: EngineDriver;
     dbinfo: DatabaseInfo;
     serverVersion: any;
-    constructor(config: GridConfig, setConfig: ChangeConfigFunc, cache: GridCache, setCache: ChangeCacheFunc, driver?: EngineDriver, dbinfo?: DatabaseInfo, serverVersion?: any);
+    currentSettings: any;
+    constructor(config: GridConfig, setConfig: ChangeConfigFunc, cache: GridCache, setCache: ChangeCacheFunc, driver?: EngineDriver, dbinfo?: DatabaseInfo, serverVersion?: any, currentSettings?: any);
     dialect: SqlDialect;
     columns: DisplayColumn[];
     formColumns: DisplayColumn[];

package/lib/GridDisplay.js

@@ -11,7 +11,7 @@ const dbgate_tools_1 = require("dbgate-tools");
 const dbgate_sqltree_1 = require("dbgate-sqltree");
 const dbgate_tools_2 = require("dbgate-tools");
 class GridDisplay {
-    constructor(config, setConfig, cache, setCache, driver, dbinfo = null, serverVersion = null) {
+    constructor(config, setConfig, cache, setCache, driver, dbinfo = null, serverVersion = null, currentSettings = null) {
         this.config = config;
         this.setConfig = setConfig;
         this.cache = cache;
@@ -19,6 +19,7 @@ class GridDisplay {
         this.driver = driver;
         this.dbinfo = dbinfo;
         this.serverVersion = serverVersion;
+        this.currentSettings = currentSettings;
         this.formColumns = [];
         this.changeSetKeyFields = null;
         this.editableStructure = null;
@@ -114,9 +115,10 @@ class GridDisplay {
         this.setConfig(cfg => (Object.assign(Object.assign({}, cfg), { searchInColumns })));
     }
     get hiddenColumnIndexes() {
+        var _a;
         // console.log('GridDisplay.hiddenColumn', this.config.hiddenColumns);
         const res = (this.config.hiddenColumns || []).map(x => lodash_1.default.findIndex(this.allColumns, y => y.uniqueName == x));
-        if (this.config.searchInColumns) {
+        if (this.config.searchInColumns && !((_a = this.currentSettings) === null || _a === void 0 ? void 0 : _a['dataGrid.showAllColumnsWhenSearch'])) {
             for (let i = 0; i < this.allColumns.length; i++) {
                 if (!(0, dbgate_tools_1.filterName)(this.config.searchInColumns, this.allColumns[i].columnName)) {
                     res.push(i);

package/lib/TableGridDisplay.d.ts

@@ -13,10 +13,11 @@ export declare class TableGridDisplay extends GridDisplay {
     displayOptions: any;
     getDictionaryDescription: DictionaryDescriptionFunc;
     isRawMode: boolean;
+    currentSettings: any;
     table: TableInfo;
     addAllExpandedColumnsToSelected: boolean;
     hintBaseColumns: DisplayColumn[];
-    constructor(tableName: NamedObjectInfo, driver: EngineDriver, config: GridConfig, setConfig: ChangeConfigFunc, cache: GridCache, setCache: ChangeCacheFunc, dbinfo: DatabaseInfo, displayOptions: any, serverVersion: any, getDictionaryDescription?: DictionaryDescriptionFunc, isReadOnly?: boolean, isRawMode?: boolean);
+    constructor(tableName: NamedObjectInfo, driver: EngineDriver, config: GridConfig, setConfig: ChangeConfigFunc, cache: GridCache, setCache: ChangeCacheFunc, dbinfo: DatabaseInfo, displayOptions: any, serverVersion: any, getDictionaryDescription?: DictionaryDescriptionFunc, isReadOnly?: boolean, isRawMode?: boolean, currentSettings?: any);
     addFormDisplayColumns(columns: any): void;
     findTable({ schemaName, pureName }: {
         schemaName?: any;
@@ -33,6 +34,7 @@ export declare class TableGridDisplay extends GridDisplay {
         uniqueName: string;
         uniquePath: string[];
         isPrimaryKey: boolean;
+        hasAutoValue: boolean;
         foreignKey: ForeignKeyInfo;
         isForeignKeyUnique: boolean;
         pairingId?: string;
@@ -75,6 +77,7 @@ export declare class TableGridDisplay extends GridDisplay {
         uniqueName: string;
         uniquePath: string[];
         isPrimaryKey: boolean;
+        hasAutoValue: boolean;
         foreignKey: ForeignKeyInfo;
         isForeignKeyUnique: boolean;
         pairingId?: string;

package/lib/TableGridDisplay.js

@@ -4,12 +4,13 @@ exports.TableGridDisplay = void 0;
 const dbgate_tools_1 = require("dbgate-tools");
 const GridDisplay_1 = require("./GridDisplay");
 class TableGridDisplay extends GridDisplay_1.GridDisplay {
-    constructor(tableName, driver, config, setConfig, cache, setCache, dbinfo, displayOptions, serverVersion, getDictionaryDescription = null, isReadOnly = false, isRawMode = false) {
-        super(config, setConfig, cache, setCache, driver, dbinfo, serverVersion);
+    constructor(tableName, driver, config, setConfig, cache, setCache, dbinfo, displayOptions, serverVersion, getDictionaryDescription = null, isReadOnly = false, isRawMode = false, currentSettings = null) {
+        super(config, setConfig, cache, setCache, driver, dbinfo, serverVersion, currentSettings);
         this.tableName = tableName;
         this.displayOptions = displayOptions;
         this.getDictionaryDescription = getDictionaryDescription;
         this.isRawMode = isRawMode;
+        this.currentSettings = currentSettings;
         this.addAllExpandedColumnsToSelected = false;
         this.table = this.findTable(tableName);
         if (!this.table) {
@@ -197,7 +198,7 @@ class TableGridDisplay extends GridDisplay_1.GridDisplay {
         const uniqueName = uniquePath.join('.');
         // console.log('this.config.addedColumns', this.config.addedColumns, uniquePath);
         const res = Object.assign(Object.assign({}, col), { pureName: table.pureName, schemaName: table.schemaName, headerText: uniquePath.length == 1 ? col.columnName : `${table.pureName}.${col.columnName}`, uniqueName,
-            uniquePath, isPrimaryKey: table.primaryKey && !!table.primaryKey.columns.find(x => x.columnName == col.columnName), foreignKey: table.foreignKeys &&
+            uniquePath, isPrimaryKey: table.primaryKey && !!table.primaryKey.columns.find(x => x.columnName == col.columnName), hasAutoValue: col.hasAutoValue, foreignKey: table.foreignKeys &&
                 table.foreignKeys.find(fk => fk.columns.length == 1 && fk.columns[0].columnName == col.columnName), isForeignKeyUnique: false });
         if (res.foreignKey) {
             const refTableInfo = this.dbinfo.tables.find(x => x.schemaName == res.foreignKey.refSchemaName && x.pureName == res.foreignKey.refTableName);

package/lib/ViewGridDisplay.d.ts

@@ -31,6 +31,7 @@ export declare class ViewGridDisplay extends GridDisplay {
         options?: [];
         canSelectMultipleOptions?: boolean;
         undropColumnName?: string;
+        hasAutoValue?: boolean;
         contentHash?: string;
         engine?: string;
     }[];
@@ -60,6 +61,7 @@ export declare class ViewGridDisplay extends GridDisplay {
         options?: [];
         canSelectMultipleOptions?: boolean;
         undropColumnName?: string;
+        hasAutoValue?: boolean;
         contentHash?: string;
         engine?: string;
     };

package/lib/chartDefinitions.d.ts

@@ -0,0 +1,80 @@
+export type ChartTypeEnum = 'bar' | 'line' | 'pie' | 'polarArea';
+export type ChartXTransformFunction = 'identity' | 'date:minute' | 'date:hour' | 'date:day' | 'date:month' | 'date:year';
+export type ChartYAggregateFunction = 'sum' | 'first' | 'last' | 'min' | 'max' | 'count' | 'avg';
+export type ChartDataLabelFormatter = 'number' | 'size:bytes' | 'size:kb' | 'size:mb' | 'size:gb';
+export declare const ChartConstDefaults: {
+    sortOrder: string;
+    windowAlign: string;
+    windowSize: number;
+    parentAggregateLimit: number;
+};
+export declare const ChartLimits: {
+    AUTODETECT_CHART_LIMIT: number;
+    AUTODETECT_MEASURES_LIMIT: number;
+    APPLY_LIMIT_AFTER_ROWS: number;
+    MAX_DISTINCT_VALUES: number;
+    VALID_VALUE_RATIO_LIMIT: number;
+    PIE_RATIO_LIMIT: number;
+    PIE_COUNT_LIMIT: number;
+};
+export interface ChartXFieldDefinition {
+    field: string;
+    title?: string;
+    transformFunction: ChartXTransformFunction;
+    sortOrder?: 'natural' | 'ascKeys' | 'descKeys' | 'ascValues' | 'descValues';
+    windowAlign?: 'start' | 'end';
+    windowSize?: number;
+    parentAggregateLimit?: number;
+}
+export interface ChartYFieldDefinition {
+    field: string;
+    title?: string;
+    aggregateFunction: ChartYAggregateFunction;
+}
+export interface ChartDefinition {
+    chartType: ChartTypeEnum;
+    title?: string;
+    pieRatioLimit?: number;
+    pieCountLimit?: number;
+    xdef: ChartXFieldDefinition;
+    ydefs: ChartYFieldDefinition[];
+    useDataLabels?: boolean;
+    dataLabelFormatter?: ChartDataLabelFormatter;
+}
+export interface ChartDateParsed {
+    year: number;
+    month?: number;
+    day?: number;
+    hour?: number;
+    minute?: number;
+    second?: number;
+    fraction?: string;
+}
+export interface ChartAvailableColumn {
+    field: string;
+}
+export interface ProcessedChart {
+    minX?: string;
+    maxX?: string;
+    rowsAdded: number;
+    buckets: {
+        [key: string]: any;
+    };
+    bucketKeysOrdered: string[];
+    bucketKeyDateParsed: {
+        [key: string]: ChartDateParsed;
+    };
+    isGivenDefinition: boolean;
+    invalidXRows: number;
+    invalidYRows: {
+        [key: string]: number;
+    };
+    validYRows: {
+        [key: string]: number;
+    };
+    topDistinctValues: {
+        [key: string]: Set<any>;
+    };
+    availableColumns: ChartAvailableColumn[];
+    definition: ChartDefinition;
+}

package/lib/chartDefinitions.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChartLimits = exports.ChartConstDefaults = void 0;
+exports.ChartConstDefaults = {
+    sortOrder: ' asc',
+    windowAlign: 'end',
+    windowSize: 100,
+    parentAggregateLimit: 200,
+};
+exports.ChartLimits = {
+    AUTODETECT_CHART_LIMIT: 10,
+    AUTODETECT_MEASURES_LIMIT: 10,
+    APPLY_LIMIT_AFTER_ROWS: 100,
+    MAX_DISTINCT_VALUES: 10,
+    VALID_VALUE_RATIO_LIMIT: 0.5,
+    PIE_RATIO_LIMIT: 0.05,
+    PIE_COUNT_LIMIT: 10, // limit for number of pie chart slices, if the number of slices is above this, it will be grouped into "Other"
+};

package/lib/chartProcessor.d.ts

@@ -0,0 +1,23 @@
+import { ChartAvailableColumn, ChartDateParsed, ChartDefinition, ProcessedChart } from './chartDefinitions';
+export declare class ChartProcessor {
+    givenDefinitions: ChartDefinition[];
+    chartsProcessing: ProcessedChart[];
+    charts: ProcessedChart[];
+    availableColumnsDict: {
+        [field: string]: ChartAvailableColumn;
+    };
+    availableColumns: ChartAvailableColumn[];
+    autoDetectCharts: boolean;
+    rowsAdded: number;
+    constructor(givenDefinitions?: ChartDefinition[]);
+    addRow(row: any): void;
+    applyLimitsOnCharts(): void;
+    addRows(...rows: any[]): void;
+    finalize(): void;
+    groupPieOtherBuckets(chart: ProcessedChart): void;
+    applyRawData(chart: ProcessedChart, row: any, dateParsed: ChartDateParsed, numericColumns: {
+        [key: string]: number;
+    }, stringColumns: {
+        [key: string]: string;
+    }): void;
+}

package/lib/chartProcessor.js

@@ -0,0 +1,296 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChartProcessor = void 0;
+const chartDefinitions_1 = require("./chartDefinitions");
+const sortBy_1 = __importDefault(require("lodash/sortBy"));
+const sum_1 = __importDefault(require("lodash/sum"));
+const chartTools_1 = require("./chartTools");
+const chartScoring_1 = require("./chartScoring");
+class ChartProcessor {
+    constructor(givenDefinitions = []) {
+        this.givenDefinitions = givenDefinitions;
+        this.chartsProcessing = [];
+        this.charts = [];
+        this.availableColumnsDict = {};
+        this.availableColumns = [];
+        this.autoDetectCharts = false;
+        this.rowsAdded = 0;
+        for (const definition of givenDefinitions) {
+            this.chartsProcessing.push({
+                definition,
+                rowsAdded: 0,
+                bucketKeysOrdered: [],
+                buckets: {},
+                bucketKeyDateParsed: {},
+                isGivenDefinition: true,
+                invalidXRows: 0,
+                invalidYRows: {},
+                availableColumns: [],
+                validYRows: {},
+                topDistinctValues: {},
+            });
+        }
+        this.autoDetectCharts = this.givenDefinitions.length == 0;
+    }
+    // findOrCreateChart(definition: ChartDefinition, isGivenDefinition: boolean): ProcessedChart {
+    //   const signatureItems = [
+    //     definition.chartType,
+    //     definition.xdef.field,
+    //     definition.xdef.transformFunction,
+    //     definition.ydefs.map(y => y.field).join(','),
+    //   ];
+    //   const signature = signatureItems.join('::');
+    //   if (this.chartsBySignature[signature]) {
+    //     return this.chartsBySignature[signature];
+    //   }
+    //   const chart: ProcessedChart = {
+    //     definition,
+    //     rowsAdded: 0,
+    //     bucketKeysOrdered: [],
+    //     buckets: {},
+    //     bucketKeyDateParsed: {},
+    //     isGivenDefinition,
+    //   };
+    //   this.chartsBySignature[signature] = chart;
+    //   return chart;
+    // }
+    addRow(row) {
+        const dateColumns = {};
+        const numericColumns = {};
+        const numericColumnsForAutodetect = {};
+        const stringColumns = {};
+        for (const [key, value] of Object.entries(row)) {
+            const number = typeof value == 'string' ? Number(value) : typeof value == 'number' ? value : NaN;
+            this.availableColumnsDict[key] = {
+                field: key,
+            };
+            const keyLower = key.toLowerCase();
+            const keyIsId = keyLower.endsWith('_id') || keyLower == 'id' || key.endsWith('Id');
+            const parsedDate = (0, chartTools_1.tryParseChartDate)(value);
+            if (parsedDate) {
+                dateColumns[key] = parsedDate;
+                continue;
+            }
+            if (!isNaN(number) && isFinite(number)) {
+                numericColumns[key] = number;
+                if (!keyIsId) {
+                    numericColumnsForAutodetect[key] = number; // for auto-detecting charts
+                }
+                continue;
+            }
+            if (typeof value === 'string' && isNaN(number) && value.length < 100) {
+                stringColumns[key] = value;
+            }
+        }
+        // const sortedNumericColumnns = Object.keys(numericColumns).sort();
+        if (this.autoDetectCharts) {
+            // create charts from data, if there are no given definitions
+            for (const datecol in dateColumns) {
+                let usedChart = this.chartsProcessing.find(chart => {
+                    var _a;
+                    return !chart.isGivenDefinition &&
+                        chart.definition.xdef.field === datecol &&
+                        ((_a = chart.definition.xdef.transformFunction) === null || _a === void 0 ? void 0 : _a.startsWith('date:'));
+                });
+                if (!usedChart &&
+                    (this.rowsAdded < chartDefinitions_1.ChartLimits.APPLY_LIMIT_AFTER_ROWS ||
+                        this.chartsProcessing.length < chartDefinitions_1.ChartLimits.AUTODETECT_CHART_LIMIT)) {
+                    usedChart = {
+                        definition: {
+                            chartType: 'line',
+                            xdef: {
+                                field: datecol,
+                                transformFunction: 'date:day',
+                            },
+                            ydefs: [],
+                        },
+                        rowsAdded: 0,
+                        bucketKeysOrdered: [],
+                        buckets: {},
+                        bucketKeyDateParsed: {},
+                        isGivenDefinition: false,
+                        invalidXRows: 0,
+                        invalidYRows: {},
+                        availableColumns: [],
+                        validYRows: {},
+                        topDistinctValues: {},
+                    };
+                    this.chartsProcessing.push(usedChart);
+                }
+                for (const [key, value] of Object.entries(row)) {
+                    if (value == null)
+                        continue;
+                    if (key == datecol)
+                        continue; // skip date column itself
+                    let existingYDef = usedChart.definition.ydefs.find(y => y.field === key);
+                    if (!existingYDef &&
+                        (this.rowsAdded < chartDefinitions_1.ChartLimits.APPLY_LIMIT_AFTER_ROWS ||
+                            usedChart.definition.ydefs.length < chartDefinitions_1.ChartLimits.AUTODETECT_MEASURES_LIMIT)) {
+                        existingYDef = {
+                            field: key,
+                            aggregateFunction: 'sum',
+                        };
+                        usedChart.definition.ydefs.push(existingYDef);
+                    }
+                }
+            }
+        }
+        // apply on all charts with this date column
+        for (const chart of this.chartsProcessing) {
+            this.applyRawData(chart, row, dateColumns[chart.definition.xdef.field], chart.isGivenDefinition ? numericColumns : numericColumnsForAutodetect, stringColumns);
+        }
+        for (let i = 0; i < this.chartsProcessing.length; i++) {
+            this.chartsProcessing[i] = (0, chartTools_1.autoAggregateCompactTimelineChart)(this.chartsProcessing[i]);
+        }
+        this.rowsAdded += 1;
+        if (this.rowsAdded == chartDefinitions_1.ChartLimits.APPLY_LIMIT_AFTER_ROWS) {
+            this.applyLimitsOnCharts();
+        }
+    }
+    applyLimitsOnCharts() {
+        const autodetectProcessingCharts = this.chartsProcessing.filter(chart => !chart.isGivenDefinition);
+        if (autodetectProcessingCharts.length > chartDefinitions_1.ChartLimits.AUTODETECT_CHART_LIMIT) {
+            const newAutodetectProcessingCharts = (0, sortBy_1.default)(this.chartsProcessing.slice(0, chartDefinitions_1.ChartLimits.AUTODETECT_CHART_LIMIT), chart => -(0, chartScoring_1.getChartScore)(chart));
+            for (const chart of autodetectProcessingCharts) {
+                chart.definition.ydefs = (0, sortBy_1.default)(chart.definition.ydefs, yfield => -(0, chartScoring_1.getChartYFieldScore)(chart, yfield)).slice(0, chartDefinitions_1.ChartLimits.AUTODETECT_MEASURES_LIMIT);
+            }
+            this.chartsProcessing = [
+                ...this.chartsProcessing.filter(chart => chart.isGivenDefinition),
+                ...newAutodetectProcessingCharts,
+            ];
+        }
+    }
+    addRows(...rows) {
+        for (const row of rows) {
+            this.addRow(row);
+        }
+    }
+    finalize() {
+        var _a;
+        this.applyLimitsOnCharts();
+        this.availableColumns = Object.values(this.availableColumnsDict);
+        for (const chart of this.chartsProcessing) {
+            let addedChart = chart;
+            if (chart.rowsAdded == 0) {
+                continue; // skip empty charts
+            }
+            const sortOrder = (_a = chart.definition.xdef.sortOrder) !== null && _a !== void 0 ? _a : 'ascKeys';
+            if (sortOrder != 'natural') {
+                if (sortOrder == 'ascKeys' || sortOrder == 'descKeys') {
+                    if (chart.definition.xdef.transformFunction.startsWith('date:')) {
+                        addedChart = (0, chartTools_1.autoAggregateCompactTimelineChart)(addedChart);
+                        (0, chartTools_1.fillChartTimelineBuckets)(addedChart);
+                    }
+                    addedChart.bucketKeysOrdered = (0, sortBy_1.default)(Object.keys(addedChart.buckets));
+                    if (sortOrder == 'descKeys') {
+                        addedChart.bucketKeysOrdered.reverse();
+                    }
+                }
+                if (sortOrder == 'ascValues' || sortOrder == 'descValues') {
+                    addedChart.bucketKeysOrdered = (0, sortBy_1.default)(Object.keys(addedChart.buckets), key => (0, chartTools_1.computeChartBucketCardinality)(addedChart.buckets[key]));
+                    if (sortOrder == 'descValues') {
+                        addedChart.bucketKeysOrdered.reverse();
+                    }
+                }
+            }
+            if (!addedChart.isGivenDefinition) {
+                addedChart = Object.assign(Object.assign({}, addedChart), { definition: Object.assign(Object.assign({}, addedChart.definition), { ydefs: addedChart.definition.ydefs.filter(y => !addedChart.invalidYRows[y.field] &&
+                            addedChart.validYRows[y.field] / addedChart.rowsAdded >= chartDefinitions_1.ChartLimits.VALID_VALUE_RATIO_LIMIT) }) });
+            }
+            if (addedChart) {
+                addedChart.availableColumns = this.availableColumns;
+                this.charts.push(addedChart);
+            }
+            this.groupPieOtherBuckets(addedChart);
+        }
+        this.charts = [
+            ...this.charts.filter(x => x.isGivenDefinition),
+            ...(0, sortBy_1.default)(this.charts.filter(x => !x.isGivenDefinition), chart => -(0, chartScoring_1.getChartScore)(chart)),
+        ];
+    }
+    groupPieOtherBuckets(chart) {
+        var _a, _b, _c;
+        if (chart.definition.chartType !== 'pie') {
+            return; // only for pie charts
+        }
+        const ratioLimit = (_a = chart.definition.pieRatioLimit) !== null && _a !== void 0 ? _a : chartDefinitions_1.ChartLimits.PIE_RATIO_LIMIT;
+        const countLimit = (_b = chart.definition.pieCountLimit) !== null && _b !== void 0 ? _b : chartDefinitions_1.ChartLimits.PIE_COUNT_LIMIT;
+        if (ratioLimit == 0 && countLimit == 0) {
+            return; // no grouping if limit is 0
+        }
+        const otherBucket = {};
+        let newBuckets = {};
+        const cardSum = (0, sum_1.default)(Object.values(chart.buckets).map(bucket => (0, chartTools_1.computeChartBucketCardinality)(bucket)));
+        if (cardSum == 0) {
+            return; // no buckets to process
+        }
+        for (const [bucketKey, bucket] of Object.entries(chart.buckets)) {
+            if ((0, chartTools_1.computeChartBucketCardinality)(bucket) / cardSum < ratioLimit) {
+                for (const field in bucket) {
+                    otherBucket[field] = ((_c = otherBucket[field]) !== null && _c !== void 0 ? _c : 0) + bucket[field];
+                }
+            }
+            else {
+                newBuckets[bucketKey] = bucket;
+            }
+        }
+        if (Object.keys(newBuckets).length > countLimit) {
+            const sortedBucketKeys = (0, sortBy_1.default)(Object.entries(newBuckets), ([, bucket]) => -(0, chartTools_1.computeChartBucketCardinality)(bucket)).map(([key]) => key);
+            const newBuckets2 = {};
+            sortedBucketKeys.forEach((key, index) => {
+                var _a;
+                if (index < countLimit) {
+                    newBuckets2[key] = newBuckets[key];
+                }
+                else {
+                    for (const field in newBuckets[key]) {
+                        otherBucket[field] = ((_a = otherBucket[field]) !== null && _a !== void 0 ? _a : 0) + newBuckets[key][field];
+                    }
+                }
+            });
+            newBuckets = newBuckets2;
+        }
+        if (Object.keys(otherBucket).length > 0) {
+            newBuckets['Other'] = otherBucket;
+        }
+        chart.buckets = newBuckets;
+        chart.bucketKeysOrdered = [...chart.bucketKeysOrdered, 'Other'].filter(key => key in newBuckets);
+    }
+    applyRawData(chart, row, dateParsed, numericColumns, stringColumns) {
+        if (chart.definition.xdef == null) {
+            return;
+        }
+        if (row[chart.definition.xdef.field] == null) {
+            return;
+        }
+        if (dateParsed == null && chart.definition.xdef.transformFunction.startsWith('date:')) {
+            chart.invalidXRows += 1;
+            return; // skip if date is invalid
+        }
+        const [bucketKey, bucketKeyParsed] = (0, chartTools_1.computeChartBucketKey)(dateParsed, chart, row);
+        if (!bucketKey) {
+            return; // skip if no bucket key
+        }
+        if (bucketKeyParsed) {
+            chart.bucketKeyDateParsed[bucketKey] = bucketKeyParsed;
+        }
+        if (chart.minX == null || bucketKey < chart.minX) {
+            chart.minX = bucketKey;
+        }
+        if (chart.maxX == null || bucketKey > chart.maxX) {
+            chart.maxX = bucketKey;
+        }
+        if (!chart.buckets[bucketKey]) {
+            chart.buckets[bucketKey] = {};
+            if (chart.definition.xdef.sortOrder == 'natural') {
+                chart.bucketKeysOrdered.push(bucketKey);
+            }
+        }
+        (0, chartTools_1.aggregateChartNumericValuesFromSource)(chart, bucketKey, numericColumns, row);
+        chart.rowsAdded += 1;
+    }
+}
+exports.ChartProcessor = ChartProcessor;

package/lib/chartScoring.d.ts

@@ -0,0 +1,3 @@
+import { ChartYFieldDefinition, ProcessedChart } from './chartDefinitions';
+export declare function getChartScore(chart: ProcessedChart): number;
+export declare function getChartYFieldScore(chart: ProcessedChart, yField: ChartYFieldDefinition): number;

package/lib/chartScoring.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChartYFieldScore = exports.getChartScore = void 0;
+const sortBy_1 = __importDefault(require("lodash/sortBy"));
+const sum_1 = __importDefault(require("lodash/sum"));
+const chartDefinitions_1 = require("./chartDefinitions");
+function getChartScore(chart) {
+    let res = 0;
+    res += chart.rowsAdded * 5;
+    const ydefScores = chart.definition.ydefs.map(yField => getChartYFieldScore(chart, yField));
+    const sorted = (0, sortBy_1.default)(ydefScores).reverse();
+    res += (0, sum_1.default)(sorted.slice(0, chartDefinitions_1.ChartLimits.AUTODETECT_MEASURES_LIMIT));
+    return res;
+}
+exports.getChartScore = getChartScore;
+function getChartYFieldScore(chart, yField) {
+    var _a, _b, _c;
+    let res = 0;
+    res += chart.validYRows[yField.field] * 5; // score for valid Y rows
+    res += ((_b = (_a = chart.topDistinctValues[yField.field]) === null || _a === void 0 ? void 0 : _a.size) !== null && _b !== void 0 ? _b : 0) * 20; // score for distinct values in Y field
+    res += chart.rowsAdded * 2; // base score for rows added
+    res -= ((_c = chart.invalidYRows[yField.field]) !== null && _c !== void 0 ? _c : 0) * 50; // penalty for invalid Y rows
+    return res;
+}
+exports.getChartYFieldScore = getChartYFieldScore;

package/lib/chartTools.d.ts

@@ -0,0 +1,19 @@
+import { ChartDateParsed, ChartXTransformFunction, ProcessedChart } from './chartDefinitions';
+export declare function getChartDebugPrint(chart: ProcessedChart): string;
+export declare function tryParseChartDate(dateInput: any): ChartDateParsed | null;
+export declare function stringifyChartDate(value: ChartDateParsed, transform: ChartXTransformFunction): string;
+export declare function incrementChartDate(value: ChartDateParsed, transform: ChartXTransformFunction): ChartDateParsed;
+export declare function computeChartBucketKey(dateParsed: ChartDateParsed, chart: ProcessedChart, row: any): [string, ChartDateParsed];
+export declare function computeDateBucketDistance(begin: ChartDateParsed, end: ChartDateParsed, transform: ChartXTransformFunction): number;
+export declare function compareChartDatesParsed(a: ChartDateParsed, b: ChartDateParsed, transform: ChartXTransformFunction): number;
+export declare function autoAggregateCompactTimelineChart(chart: ProcessedChart): ProcessedChart;
+export declare function aggregateChartNumericValuesFromSource(chart: ProcessedChart, bucketKey: string, numericColumns: {
+    [key: string]: number;
+}, row: any): void;
+export declare function aggregateChartNumericValuesFromChild(chart: ProcessedChart, bucketKey: string, childBucketValues: {
+    [key: string]: any;
+}): void;
+export declare function fillChartTimelineBuckets(chart: ProcessedChart): void;
+export declare function computeChartBucketCardinality(bucket: {
+    [key: string]: any;
+}): number;