2020-06-26 11:25:02 +02:00
|
|
|
// Copyright: Ankitects Pty Ltd and contributors
|
|
|
|
// License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
|
|
|
|
|
|
|
|
/* eslint
|
|
|
|
@typescript-eslint/no-non-null-assertion: "off",
|
|
|
|
@typescript-eslint/no-explicit-any: "off",
|
|
|
|
*/
|
|
|
|
|
2020-11-05 02:01:30 +01:00
|
|
|
import type pb from "anki/backend_proto";
|
2020-06-27 13:10:17 +02:00
|
|
|
import { extent, histogram, rollup, sum, Bin } from "d3-array";
|
2020-06-26 11:25:02 +02:00
|
|
|
import { scaleLinear, scaleSequential } from "d3-scale";
|
2020-11-05 02:01:30 +01:00
|
|
|
import { CardQueue } from "anki/cards";
|
2020-11-01 05:26:58 +01:00
|
|
|
import type { HistogramData } from "./histogram-graph";
|
2020-06-26 11:25:02 +02:00
|
|
|
import { interpolateGreens } from "d3-scale-chromatic";
|
2020-11-05 02:01:30 +01:00
|
|
|
import { dayLabel } from "anki/time";
|
|
|
|
import type { I18n } from "anki/i18n";
|
2020-11-01 05:26:58 +01:00
|
|
|
import { GraphRange } from "./graph-helpers";
|
|
|
|
import type { TableDatum } from "./graph-helpers";
|
2020-06-26 11:25:02 +02:00
|
|
|
|
|
|
|
export interface GraphData {
|
|
|
|
dueCounts: Map<number, number>;
|
2020-08-10 06:37:23 +02:00
|
|
|
haveBacklog: boolean;
|
2020-06-26 11:25:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
export function gatherData(data: pb.BackendProto.GraphsOut): GraphData {
|
2021-01-07 14:43:34 +01:00
|
|
|
const isLearning = (card: pb.BackendProto.Card): boolean =>
|
|
|
|
[CardQueue.Learn, CardQueue.PreviewRepeat].includes(card.queue);
|
|
|
|
|
2020-08-10 06:37:23 +02:00
|
|
|
let haveBacklog = false;
|
2020-06-26 11:25:02 +02:00
|
|
|
const due = (data.cards as pb.BackendProto.Card[])
|
2021-01-07 14:43:34 +01:00
|
|
|
.filter((c: pb.BackendProto.Card) => {
|
|
|
|
// reviews
|
|
|
|
return (
|
2020-07-24 03:09:22 +02:00
|
|
|
[CardQueue.Review, CardQueue.DayLearn].includes(c.queue) ||
|
2021-01-07 14:43:34 +01:00
|
|
|
// or learning cards
|
|
|
|
isLearning(c)
|
|
|
|
);
|
|
|
|
})
|
|
|
|
.map((c: pb.BackendProto.Card) => {
|
|
|
|
let dueDay: number;
|
|
|
|
|
|
|
|
if (isLearning(c)) {
|
2021-01-07 19:36:08 +01:00
|
|
|
const offset = c.due - data.nextDayAtSecs;
|
2021-01-07 14:43:34 +01:00
|
|
|
dueDay = Math.floor(offset / 86_400) + 1;
|
2020-07-26 02:28:56 +02:00
|
|
|
} else {
|
2020-07-27 04:10:45 +02:00
|
|
|
// - testing just odue fails on day 1
|
|
|
|
// - testing just odid fails on lapsed cards that
|
|
|
|
// have due calculated at regraduation time
|
2020-08-31 09:09:49 +02:00
|
|
|
const due = c.originalDeckId && c.originalDue ? c.originalDue : c.due;
|
2021-01-07 14:43:34 +01:00
|
|
|
dueDay = due - data.daysElapsed;
|
2020-07-26 02:28:56 +02:00
|
|
|
}
|
2021-01-07 14:43:34 +01:00
|
|
|
|
|
|
|
haveBacklog = haveBacklog || dueDay < 0;
|
|
|
|
|
2021-01-07 19:36:08 +01:00
|
|
|
return dueDay;
|
2020-07-26 02:28:56 +02:00
|
|
|
});
|
2020-07-24 03:09:22 +02:00
|
|
|
|
2020-06-26 11:25:02 +02:00
|
|
|
const dueCounts = rollup(
|
|
|
|
due,
|
|
|
|
(v) => v.length,
|
|
|
|
(d) => d
|
|
|
|
);
|
2020-08-10 06:37:23 +02:00
|
|
|
return { dueCounts, haveBacklog };
|
2020-06-26 11:25:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
function binValue(d: Bin<Map<number, number>, number>): number {
|
|
|
|
return sum(d, (d) => d[1]);
|
|
|
|
}
|
|
|
|
|
2020-08-10 06:37:23 +02:00
|
|
|
export interface FutureDueOut {
|
|
|
|
histogramData: HistogramData | null;
|
|
|
|
tableData: TableDatum[];
|
|
|
|
}
|
|
|
|
|
2021-01-25 16:33:18 +01:00
|
|
|
function makeQuery(start: number, end: number): string {
|
|
|
|
if (start === end) {
|
|
|
|
return `"prop:due=${start}"`;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
const fromQuery = `"prop:due>=${start}"`;
|
|
|
|
const tillQuery = `"prop:due<=${end}"`;
|
|
|
|
return `${fromQuery} AND ${tillQuery}`;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-26 11:25:02 +02:00
|
|
|
export function buildHistogram(
|
|
|
|
sourceData: GraphData,
|
2020-07-17 05:46:06 +02:00
|
|
|
range: GraphRange,
|
2020-06-28 11:34:19 +02:00
|
|
|
backlog: boolean,
|
2021-01-25 16:33:18 +01:00
|
|
|
i18n: I18n,
|
|
|
|
dispatch: any,
|
2020-08-10 06:37:23 +02:00
|
|
|
): FutureDueOut {
|
|
|
|
const output = { histogramData: null, tableData: [] };
|
2020-06-26 11:25:02 +02:00
|
|
|
// get min/max
|
|
|
|
const data = sourceData.dueCounts;
|
|
|
|
if (!data) {
|
2020-08-10 06:37:23 +02:00
|
|
|
return output;
|
2020-06-26 11:25:02 +02:00
|
|
|
}
|
|
|
|
|
2020-06-28 11:34:19 +02:00
|
|
|
const [xMinOrig, origXMax] = extent<number>(data.keys());
|
|
|
|
let xMin = xMinOrig;
|
|
|
|
if (!backlog) {
|
|
|
|
xMin = 0;
|
|
|
|
}
|
2020-06-26 11:25:02 +02:00
|
|
|
let xMax = origXMax;
|
|
|
|
|
|
|
|
// cap max to selected range
|
|
|
|
switch (range) {
|
2020-07-17 05:46:06 +02:00
|
|
|
case GraphRange.Month:
|
2020-06-26 11:25:02 +02:00
|
|
|
xMax = 31;
|
|
|
|
break;
|
2020-07-17 05:46:06 +02:00
|
|
|
case GraphRange.ThreeMonths:
|
2020-06-26 11:25:02 +02:00
|
|
|
xMax = 90;
|
|
|
|
break;
|
2020-07-17 05:46:06 +02:00
|
|
|
case GraphRange.Year:
|
2020-06-26 11:25:02 +02:00
|
|
|
xMax = 365;
|
|
|
|
break;
|
2020-07-17 05:46:06 +02:00
|
|
|
case GraphRange.AllTime:
|
2020-06-26 11:25:02 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
// cap bars to available range
|
|
|
|
const desiredBars = Math.min(70, xMax! - xMin!);
|
|
|
|
|
2020-08-04 07:15:57 +02:00
|
|
|
const x = scaleLinear().domain([xMin!, xMax!]);
|
2020-06-26 11:25:02 +02:00
|
|
|
const bins = histogram()
|
|
|
|
.value((m) => {
|
|
|
|
return m[0];
|
|
|
|
})
|
|
|
|
.domain(x.domain() as any)
|
|
|
|
.thresholds(x.ticks(desiredBars))(data.entries() as any);
|
|
|
|
|
2020-07-06 06:01:49 +02:00
|
|
|
// empty graph?
|
|
|
|
if (!sum(bins, (bin) => bin.length)) {
|
2020-08-10 06:37:23 +02:00
|
|
|
return output;
|
2020-07-06 06:01:49 +02:00
|
|
|
}
|
|
|
|
|
2020-08-05 07:35:07 +02:00
|
|
|
const adjustedRange = scaleLinear().range([0.7, 0.3]);
|
2020-06-28 06:21:31 +02:00
|
|
|
const colourScale = scaleSequential((n) =>
|
2020-09-29 14:13:25 +02:00
|
|
|
interpolateGreens(adjustedRange(n)!)
|
2020-08-04 07:15:57 +02:00
|
|
|
).domain([xMin!, xMax!]);
|
2020-06-26 11:25:02 +02:00
|
|
|
|
|
|
|
const total = sum(bins as any, binValue);
|
|
|
|
|
2020-06-28 11:34:19 +02:00
|
|
|
function hoverText(
|
|
|
|
data: HistogramData,
|
|
|
|
binIdx: number,
|
|
|
|
cumulative: number,
|
|
|
|
_percent: number
|
|
|
|
): string {
|
|
|
|
const bin = data.bins[binIdx];
|
|
|
|
const days = dayLabel(i18n, bin.x0!, bin.x1!);
|
|
|
|
const cards = i18n.tr(i18n.TR.STATISTICS_CARDS_DUE, {
|
|
|
|
cards: binValue(data.bins[binIdx] as any),
|
|
|
|
});
|
|
|
|
const totalLabel = i18n.tr(i18n.TR.STATISTICS_RUNNING_TOTAL);
|
|
|
|
|
|
|
|
return `${days}:<br>${cards}<br>${totalLabel}: ${cumulative}`;
|
|
|
|
}
|
|
|
|
|
2021-01-25 16:33:18 +01:00
|
|
|
function onClick(bin: Bin<number, number>): void {
|
2021-01-08 13:59:33 +01:00
|
|
|
const start = bin.x0!;
|
|
|
|
const end = bin.x1! - 1;
|
2021-01-25 16:33:18 +01:00
|
|
|
const query = makeQuery(start, end);
|
|
|
|
dispatch("search", { query });
|
2021-01-08 13:59:33 +01:00
|
|
|
}
|
|
|
|
|
2020-08-04 07:15:57 +02:00
|
|
|
const periodDays = xMax! - xMin!;
|
|
|
|
const tableData = [
|
|
|
|
{
|
|
|
|
label: i18n.tr(i18n.TR.STATISTICS_TOTAL),
|
|
|
|
value: i18n.tr(i18n.TR.STATISTICS_REVIEWS, { reviews: total }),
|
|
|
|
},
|
|
|
|
{
|
|
|
|
label: i18n.tr(i18n.TR.STATISTICS_AVERAGE),
|
|
|
|
value: i18n.tr(i18n.TR.STATISTICS_REVIEWS_PER_DAY, {
|
|
|
|
count: Math.round(total / periodDays),
|
|
|
|
}),
|
|
|
|
},
|
|
|
|
{
|
|
|
|
label: i18n.tr(i18n.TR.STATISTICS_DUE_TOMORROW),
|
|
|
|
value: i18n.tr(i18n.TR.STATISTICS_REVIEWS, {
|
|
|
|
reviews: sourceData.dueCounts.get(1) ?? 0,
|
|
|
|
}),
|
|
|
|
},
|
|
|
|
];
|
|
|
|
|
2020-08-10 06:37:23 +02:00
|
|
|
return {
|
|
|
|
histogramData: {
|
2020-08-04 07:15:57 +02:00
|
|
|
scale: x,
|
|
|
|
bins,
|
|
|
|
total,
|
|
|
|
hoverText,
|
2021-01-25 16:33:18 +01:00
|
|
|
onClick,
|
2020-08-04 07:15:57 +02:00
|
|
|
showArea: true,
|
|
|
|
colourScale,
|
|
|
|
binValue,
|
|
|
|
},
|
|
|
|
tableData,
|
2020-08-10 06:37:23 +02:00
|
|
|
};
|
2020-06-26 11:25:02 +02:00
|
|
|
}
|