@lightdash/common 0.1477.4 → 0.1478.0

package/dist/types/conditionalFormatting.d.ts

@@ -1,12 +1,17 @@
 import { type ConditionalOperator, type ConditionalRule } from './conditionalRule';
 import { type FieldTarget } from './filter';
-export type ConditionalFormattingWithConditionalOperator<T = number> = ConditionalRule<ConditionalOperator, T> & {
-    values: T[];
-};
-export type ConditionalFormattingWithRange<T = number> = {
+export type ConditionalFormattingMinMax<T = number> = {
     min: T;
     max: T;
 };
+export type ConditionalFormattingColorRange = {
+    start: string;
+    end: string;
+    steps: number;
+};
+export type ConditionalFormattingWithConditionalOperator<T = number> = ConditionalRule<ConditionalOperator, T> & {
+    values: T[];
+};
 export type ConditionalFormattingConfigWithSingleColor = {
     target: FieldTarget | null;
     color: string;
@@ -15,12 +20,8 @@ export type ConditionalFormattingConfigWithSingleColor = {
 export declare const isConditionalFormattingConfigWithSingleColor: (rule: ConditionalFormattingConfig) => rule is ConditionalFormattingConfigWithSingleColor;
 export type ConditionalFormattingConfigWithColorRange = {
     target: FieldTarget | null;
-    color: {
-        start: string;
-        end: string;
-        steps: 5;
-    };
-    rule: ConditionalFormattingWithRange;
+    color: ConditionalFormattingColorRange;
+    rule: ConditionalFormattingMinMax<number | 'auto'>;
 };
 export declare const isConditionalFormattingConfigWithColorRange: (config: ConditionalFormattingConfig) => config is ConditionalFormattingConfigWithColorRange;
 export type ConditionalFormattingConfig = ConditionalFormattingConfigWithSingleColor | ConditionalFormattingConfigWithColorRange;
@@ -29,3 +30,4 @@ export declare enum ConditionalFormattingConfigType {
     Range = "range"
 }
 export declare const getConditionalFormattingConfigType: (rule: ConditionalFormattingConfig) => ConditionalFormattingConfigType;
+export type ConditionalFormattingMinMaxMap = Record<string, ConditionalFormattingMinMax>;

package/dist/utils/conditionalFormatting.d.ts

@@ -1,5 +1,5 @@
 import type { ItemsMap } from '..';
-import { type ConditionalFormattingConfig, type ConditionalFormattingConfigWithColorRange, type ConditionalFormattingConfigWithSingleColor, type ConditionalFormattingWithConditionalOperator } from '../types/conditionalFormatting';
+import { type ConditionalFormattingColorRange, type ConditionalFormattingConfig, type ConditionalFormattingConfigWithColorRange, type ConditionalFormattingConfigWithSingleColor, type ConditionalFormattingMinMax, type ConditionalFormattingMinMaxMap, type ConditionalFormattingWithConditionalOperator } from '../types/conditionalFormatting';
 import { type ConditionalRuleLabels } from '../types/conditionalRule';
 import { type FilterableItem } from '../types/field';
 import { type FieldTarget } from '../types/filter';
@@ -7,17 +7,35 @@ export declare const createConditionalFormatingRule: () => ConditionalFormatting
 export declare const createConditionalFormattingConfigWithSingleColor: (defaultColor: string, target?: FieldTarget | null) => ConditionalFormattingConfigWithSingleColor;
 export declare const createConditionalFormattingConfigWithColorRange: (defaultColor: string, target?: FieldTarget | null) => ConditionalFormattingConfigWithColorRange;
 export declare const hasPercentageFormat: (field: ItemsMap[string] | undefined) => boolean;
-export declare const hasMatchingConditionalRules: (field: ItemsMap[string], value: unknown, config: ConditionalFormattingConfig | undefined) => boolean;
-export declare const getConditionalFormattingConfig: (field: ItemsMap[string] | undefined, value: unknown | undefined, conditionalFormattings: ConditionalFormattingConfig[] | undefined) => ConditionalFormattingConfig | undefined;
+export declare const convertFormattedValue: <T extends unknown>(value: T, field: ItemsMap[string] | undefined) => number | T;
+export declare const getMinMaxFromMinMaxMap: (minMaxMap: ConditionalFormattingMinMaxMap) => {
+    min: number;
+    max: number;
+};
+export declare const hasMatchingConditionalRules: (field: ItemsMap[string], value: unknown, minMaxMap: ConditionalFormattingMinMaxMap, config: ConditionalFormattingConfig | undefined) => boolean;
+export declare const getConditionalFormattingConfig: ({ field, value, minMaxMap, conditionalFormattings, }: {
+    field: ItemsMap[string] | undefined;
+    value: unknown | undefined;
+    minMaxMap: ConditionalFormattingMinMaxMap | undefined;
+    conditionalFormattings: ConditionalFormattingConfig[] | undefined;
+}) => ConditionalFormattingConfig | undefined;
 export declare const getConditionalFormattingDescription: (field: ItemsMap[string] | undefined, conditionalFormattingConfig: ConditionalFormattingConfig | undefined, getConditionalRuleLabel: (rule: ConditionalFormattingWithConditionalOperator, item: FilterableItem) => ConditionalRuleLabels) => string | undefined;
-export declare const getConditionalFormattingColor: (field: ItemsMap[string] | undefined, value: unknown, conditionalFormattingConfig: ConditionalFormattingConfig | undefined, getColorFromRange: (value: number, config: {
-    color: {
-        start: string;
-        end: string;
-        steps: number;
-    };
-    rule: {
-        min: number;
-        max: number;
-    };
-}) => string | undefined) => string | undefined;
+type GetColorFromRangeFunction = (value: number, colorRange: ConditionalFormattingColorRange, minMaxRange: ConditionalFormattingMinMax) => string | undefined;
+export declare const getConditionalFormattingColorWithColorRange: ({ field, value, config, minMaxMap, getColorFromRange, }: {
+    field: ItemsMap[string] | undefined;
+    value: unknown;
+    config: ConditionalFormattingConfigWithColorRange;
+    minMaxMap: ConditionalFormattingMinMaxMap | undefined;
+    getColorFromRange: GetColorFromRangeFunction;
+}) => string | undefined;
+export declare const getConditionalFormattingColorWithSingleColor: ({ config, }: {
+    config: ConditionalFormattingConfigWithSingleColor;
+}) => string;
+export declare const getConditionalFormattingColor: ({ field, value, config, minMaxMap, getColorFromRange, }: {
+    field: ItemsMap[string] | undefined;
+    value: unknown;
+    config: ConditionalFormattingConfig | undefined;
+    minMaxMap: ConditionalFormattingMinMaxMap | undefined;
+    getColorFromRange: GetColorFromRangeFunction;
+}) => string | undefined;
+export {};

package/dist/utils/conditionalFormatting.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConditionalFormattingColor = exports.getConditionalFormattingDescription = exports.getConditionalFormattingConfig = exports.hasMatchingConditionalRules = exports.hasPercentageFormat = exports.createConditionalFormattingConfigWithColorRange = exports.createConditionalFormattingConfigWithSingleColor = exports.createConditionalFormatingRule = void 0;
+exports.getConditionalFormattingColor = exports.getConditionalFormattingColorWithSingleColor = exports.getConditionalFormattingColorWithColorRange = exports.getConditionalFormattingDescription = exports.getConditionalFormattingConfig = exports.hasMatchingConditionalRules = exports.getMinMaxFromMinMaxMap = exports.convertFormattedValue = exports.hasPercentageFormat = exports.createConditionalFormattingConfigWithColorRange = exports.createConditionalFormattingConfigWithSingleColor = exports.createConditionalFormatingRule = void 0;
 const tslib_1 = require("tslib");
+const lodash_1 = require("lodash");
 const uuid_1 = require("uuid");
 const conditionalFormatting_1 = require("../types/conditionalFormatting");
 const conditionalRule_1 = require("../types/conditionalRule");
@@ -49,11 +50,22 @@ const convertFormattedValue = (value, field) => {
     }
     return value;
 };
-const hasMatchingConditionalRules = (field, value, config) => {
+exports.convertFormattedValue = convertFormattedValue;
+const getMinMaxFromMinMaxMap = (minMaxMap) => ({
+    min: Math.min(...Object.values(minMaxMap).map((m) => m.min)),
+    max: Math.max(...Object.values(minMaxMap).map((m) => m.max)),
+});
+exports.getMinMaxFromMinMaxMap = getMinMaxFromMinMaxMap;
+const hasMatchingConditionalRules = (field, value, minMaxMap, config) => {
     if (!config)
         return false;
     const parsedValue = typeof value === 'string' ? Number(value) : value;
-    const convertedValue = convertFormattedValue(parsedValue, field);
+    const convertedValue = (0, exports.convertFormattedValue)(parsedValue, field);
+    const currentFieldId = (0, item_1.getItemId)(field);
+    const targetFieldId = config.target?.fieldId;
+    if (targetFieldId !== undefined && targetFieldId !== currentFieldId) {
+        return false;
+    }
     if ((0, conditionalFormatting_1.isConditionalFormattingConfigWithSingleColor)(config)) {
         return config.rules.every((rule) => {
             switch (rule.operator) {
@@ -94,23 +106,37 @@ const hasMatchingConditionalRules = (field, value, config) => {
     if ((0, conditionalFormatting_1.isConditionalFormattingConfigWithColorRange)(config)) {
         if (typeof convertedValue !== 'number')
             return false;
-        return (convertedValue >= config.rule.min &&
-            convertedValue <= config.rule.max);
+        let min;
+        let max;
+        if (config.rule.min === 'auto') {
+            min = targetFieldId
+                ? minMaxMap[targetFieldId].min
+                : (0, exports.getMinMaxFromMinMaxMap)(minMaxMap).min;
+        }
+        else {
+            min = config.rule.min;
+        }
+        if (config.rule.max === 'auto') {
+            max = targetFieldId
+                ? minMaxMap[targetFieldId].max
+                : (0, exports.getMinMaxFromMinMaxMap)(minMaxMap).max;
+        }
+        else {
+            max = config.rule.max;
+        }
+        return convertedValue >= min && convertedValue <= max;
     }
     return (0, assertUnreachable_1.default)(config, 'Unknown conditional formatting config');
 };
 exports.hasMatchingConditionalRules = hasMatchingConditionalRules;
-const getConditionalFormattingConfig = (field, value, conditionalFormattings) => {
+const getConditionalFormattingConfig = ({ field, value, minMaxMap = {}, conditionalFormattings, }) => {
     // For backwards compatibility with old table calculations without type
     const isCalculationTypeUndefined = field && (0, field_1.isTableCalculation)(field) && field.type === undefined;
     if (!conditionalFormattings ||
         !field ||
         (!(0, item_1.isNumericItem)(field) && !isCalculationTypeUndefined))
         return undefined;
-    const fieldConfigs = conditionalFormattings.filter((c) => c.target?.fieldId === (0, item_1.getItemId)(field) || !c.target);
-    return fieldConfigs
-        .reverse()
-        .find((config) => (0, exports.hasMatchingConditionalRules)(field, value, config));
+    return (0, lodash_1.findLast)(conditionalFormattings, (config) => (0, exports.hasMatchingConditionalRules)(field, value, minMaxMap, config));
 };
 exports.getConditionalFormattingConfig = getConditionalFormattingConfig;
 const getConditionalFormattingDescription = (field, conditionalFormattingConfig, getConditionalRuleLabel) => {
@@ -119,8 +145,12 @@ const getConditionalFormattingDescription = (field, conditionalFormattingConfig,
     }
     if ((0, conditionalFormatting_1.isConditionalFormattingConfigWithColorRange)(conditionalFormattingConfig)) {
         return [
-            `is greater than or equal to ${conditionalFormattingConfig.rule.min}`,
-            `is less than or equal to ${conditionalFormattingConfig.rule.max}`,
+            `is greater than or equal to ${conditionalFormattingConfig.rule.min === 'auto'
+                ? 'min value in table'
+                : conditionalFormattingConfig.rule.min}`,
+            `is less than or equal to ${conditionalFormattingConfig.rule.max === 'auto'
+                ? 'max value in table'
+                : conditionalFormattingConfig.rule.max}`,
         ].join(' and ');
     }
     if ((0, conditionalFormatting_1.isConditionalFormattingConfigWithSingleColor)(conditionalFormattingConfig)) {
@@ -132,20 +162,53 @@ const getConditionalFormattingDescription = (field, conditionalFormattingConfig,
     return (0, assertUnreachable_1.default)(conditionalFormattingConfig, 'Unknown conditional formatting config');
 };
 exports.getConditionalFormattingDescription = getConditionalFormattingDescription;
-const getConditionalFormattingColor = (field, value, conditionalFormattingConfig, getColorFromRange) => {
-    if (!conditionalFormattingConfig) {
+const getConditionalFormattingColorWithColorRange = ({ field, value, config, minMaxMap = {}, getColorFromRange, }) => {
+    if (!field)
+        return undefined;
+    const numericValue = typeof value === 'string' ? parseFloat(value) : value;
+    const convertedValue = (0, exports.convertFormattedValue)(numericValue, field);
+    const currentFieldId = (0, item_1.getItemId)(field);
+    const targetFieldId = config.target?.fieldId;
+    if (targetFieldId !== undefined && targetFieldId !== currentFieldId) {
         return undefined;
     }
-    if ((0, conditionalFormatting_1.isConditionalFormattingConfigWithColorRange)(conditionalFormattingConfig)) {
-        const numericValue = typeof value === 'string' ? parseFloat(value) : value;
-        const convertedValue = convertFormattedValue(numericValue, field);
-        if (typeof convertedValue !== 'number')
-            return undefined;
-        return getColorFromRange(convertedValue, conditionalFormattingConfig);
+    if (typeof convertedValue !== 'number')
+        return undefined;
+    let min;
+    let max;
+    if (config.rule.min === 'auto') {
+        min = targetFieldId
+            ? minMaxMap[targetFieldId].min
+            : (0, exports.getMinMaxFromMinMaxMap)(minMaxMap).min;
     }
-    if ((0, conditionalFormatting_1.isConditionalFormattingConfigWithSingleColor)(conditionalFormattingConfig)) {
-        return conditionalFormattingConfig.color;
+    else {
+        min = config.rule.min;
     }
-    return (0, assertUnreachable_1.default)(conditionalFormattingConfig, 'Unknown conditional formatting config');
+    if (config.rule.max === 'auto') {
+        max = targetFieldId
+            ? minMaxMap[targetFieldId].max
+            : (0, exports.getMinMaxFromMinMaxMap)(minMaxMap).max;
+    }
+    else {
+        max = config.rule.max;
+    }
+    return getColorFromRange(convertedValue, config.color, { min, max });
+};
+exports.getConditionalFormattingColorWithColorRange = getConditionalFormattingColorWithColorRange;
+const getConditionalFormattingColorWithSingleColor = ({ config, }) => config.color;
+exports.getConditionalFormattingColorWithSingleColor = getConditionalFormattingColorWithSingleColor;
+const getConditionalFormattingColor = ({ field, value, config, minMaxMap, getColorFromRange, }) => {
+    if (!config)
+        return undefined;
+    if ((0, conditionalFormatting_1.isConditionalFormattingConfigWithSingleColor)(config)) {
+        return (0, exports.getConditionalFormattingColorWithSingleColor)({ config });
+    }
+    return (0, exports.getConditionalFormattingColorWithColorRange)({
+        field,
+        value,
+        config,
+        minMaxMap,
+        getColorFromRange,
+    });
 };
 exports.getConditionalFormattingColor = getConditionalFormattingColor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightdash/common",
-  "version": "0.1477.4",
+  "version": "0.1478.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [