The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:
TypeScript analyticsbibusiness-intelligencebusinessintelligenceclojuredashboarddatadata-analysisdata-visualizationdatabasemetabasemysqlpostgrespostgresqlreportingslacksql-editorvisualization
import * as Lib from "metabase-lib";
import type {
CardDisplayType,
DatasetColumn,
VisualizationSettings,
} from "metabase-types/api";
type DefaultDisplay = {
display: CardDisplayType;
settings?: Partial<VisualizationSettings>;
};
export const defaultDisplay = (
query: Lib.Query,
resultColumns?: readonly DatasetColumn[],
): DefaultDisplay => {
const { isNative } = Lib.queryDisplayInfo(query);
if (isNative) {
return { display: "table" };
}
const stageIndex = -1;
const aggregations = Lib.aggregations(query, stageIndex);
const breakouts = Lib.breakouts(query, stageIndex);
if (aggregations.length === 0 && breakouts.length === 0) {
return { display: "table" };
}
if (aggregations.length === 1 && breakouts.length === 0) {
return { display: "scalar" };
}
if (aggregations.length === 1 && breakouts.length === 1) {
const [{ column }] = getBreakoutsWithColumns(
query,
stageIndex,
breakouts,
resultColumns,
);
if (column != null && Lib.isState(column)) {
return {
display: "map",
settings: {
"map.type": "region",
"map.region": "us_states",
},
};
}
if (column != null && Lib.isCountry(column)) {
return {
display: "map",
settings: {
"map.type": "region",
"map.region": "world_countries",
},
};
}
}
if (aggregations.length >= 1 && breakouts.length === 1) {
const [{ breakout, column }] = getBreakoutsWithColumns(
query,
stageIndex,
breakouts,
resultColumns,
);
const breakoutInfo = Lib.displayInfo(query, stageIndex, breakout);
if (breakoutInfo.isTemporalExtraction) {
return { display: "bar" };
}
if (column != null && Lib.isTemporal(column)) {
return { display: "line" };
}
const binning = Lib.binning(breakout);
const isBinned = binning !== null;
if (isBinned) {
return { display: "bar" };
}
if (column != null && (Lib.isBoolean(column) || Lib.isCategory(column))) {
return { display: "bar" };
}
}
if (aggregations.length === 1 && breakouts.length === 2) {
const breakoutsWithColumns = getBreakoutsWithColumns(
query,
stageIndex,
breakouts,
resultColumns,
);
const isAnyBreakoutTemporal = breakoutsWithColumns.some(({ column }) => {
return column != null && Lib.isTemporal(column);
});
if (isAnyBreakoutTemporal) {
return { display: "line" };
}
const areBreakoutsCoordinates = breakoutsWithColumns.every(({ column }) => {
return column != null && Lib.isCoordinate(column);
});
if (areBreakoutsCoordinates) {
const binningOne = Lib.binning(breakouts[0]);
const binningTwo = Lib.binning(breakouts[1]);
const areBothBinned = binningOne !== null && binningTwo !== null;
if (areBothBinned) {
return {
display: "map",
settings: {
"map.type": "grid",
},
};
}
return {
display: "map",
settings: {
"map.type": "pin",
},
};
}
const areBreakoutsCategories = breakoutsWithColumns.every(({ column }) => {
return (
column != null && (Lib.isBoolean(column) || Lib.isCategory(column))
);
});
if (areBreakoutsCategories) {
return { display: "bar" };
}
}
return { display: "table" };
};
const getBreakoutsWithColumns = (
query: Lib.Query,
stageIndex: number,
breakouts: Lib.BreakoutClause[],
resultColumns?: readonly DatasetColumn[],
) => {
const resultBreakoutColumnTypes = getResultBreakoutColumnTypes(
resultColumns,
breakouts.length,
);
return breakouts.map((breakout, index) => {
const column =
Lib.breakoutColumn(query, stageIndex, breakout) ??
resultBreakoutColumnTypes?.[index] ??
null;
return { breakout, column };
});
};
const getResultBreakoutColumnTypes = (
resultColumns: readonly DatasetColumn[] | undefined,
breakoutCount: number,
): Lib.ColumnTypeInfo[] | null => {
if (resultColumns == null) {
return null;
}
const breakoutColumns = resultColumns.filter(
(column) => column.source === "breakout",
);
if (breakoutColumns.length !== breakoutCount) {
return [];
}
return breakoutColumns.map(Lib.legacyColumnTypeInfo);
};