is . or ''
//
// **/.. is *brutal* for filesystem walking performance, because
// it effectively resets the recursive walk each time it occurs,
// and ** cannot be reduced out by a .. pattern part like a regexp
// or most strings (other than .., ., and '') can be.
//
// /**/..//
/ -> {/..//
/,/**//
/}
// // -> /
// //../ -> /
// **/**/ -> **/
//
// **/*/ -> */**/ <== not valid because ** doesn't follow
// this WOULD be allowed if ** did follow symlinks, or * didn't
firstPhasePreProcess(globParts) {
let didSomething = false;
do {
didSomething = false;
for (let parts of globParts) {
let gs = -1;
while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
let gss = gs;
while (parts[gss + 1] === "**") {
gss++;
}
if (gss > gs) {
parts.splice(gs + 1, gss - gs);
}
let next = parts[gs + 1];
const p2 = parts[gs + 2];
const p22 = parts[gs + 3];
if (next !== "..")
continue;
if (!p2 || p2 === "." || p2 === ".." || !p22 || p22 === "." || p22 === "..") {
continue;
}
didSomething = true;
parts.splice(gs, 1);
const other = parts.slice(0);
other[gs] = "**";
globParts.push(other);
gs--;
}
if (!this.preserveMultipleSlashes) {
for (let i2 = 1; i2 < parts.length - 1; i2++) {
const p2 = parts[i2];
if (i2 === 1 && p2 === "" && parts[0] === "")
continue;
if (p2 === "." || p2 === "") {
didSomething = true;
parts.splice(i2, 1);
i2--;
}
}
if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
didSomething = true;
parts.pop();
}
}
let dd = 0;
while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
const p2 = parts[dd - 1];
if (p2 && p2 !== "." && p2 !== ".." && p2 !== "**") {
didSomething = true;
const needDot = dd === 1 && parts[dd + 1] === "**";
const splin = needDot ? ["."] : [];
parts.splice(dd - 1, 2, ...splin);
if (parts.length === 0)
parts.push("");
dd -= 2;
}
}
}
} while (didSomething);
return globParts;
}
// second phase: multi-pattern dedupes
// {/*/,//} -> /*/
// {/,/} -> /
// {/**/,/} -> /**/
//
// {/**/,/**//} -> /**/
// ^-- not valid because ** doens't follow symlinks
secondPhasePreProcess(globParts) {
for (let i2 = 0; i2 < globParts.length - 1; i2++) {
for (let j2 = i2 + 1; j2 < globParts.length; j2++) {
const matched = this.partsMatch(globParts[i2], globParts[j2], !this.preserveMultipleSlashes);
if (matched) {
globParts[i2] = [];
globParts[j2] = matched;
break;
}
}
}
return globParts.filter((gs) => gs.length);
}
partsMatch(a2, b2, emptyGSMatch = false) {
let ai = 0;
let bi = 0;
let result = [];
let which = "";
while (ai < a2.length && bi < b2.length) {
if (a2[ai] === b2[bi]) {
result.push(which === "b" ? b2[bi] : a2[ai]);
ai++;
bi++;
} else if (emptyGSMatch && a2[ai] === "**" && b2[bi] === a2[ai + 1]) {
result.push(a2[ai]);
ai++;
} else if (emptyGSMatch && b2[bi] === "**" && a2[ai] === b2[bi + 1]) {
result.push(b2[bi]);
bi++;
} else if (a2[ai] === "*" && b2[bi] && (this.options.dot || !b2[bi].startsWith(".")) && b2[bi] !== "**") {
if (which === "b")
return false;
which = "a";
result.push(a2[ai]);
ai++;
bi++;
} else if (b2[bi] === "*" && a2[ai] && (this.options.dot || !a2[ai].startsWith(".")) && a2[ai] !== "**") {
if (which === "a")
return false;
which = "b";
result.push(b2[bi]);
ai++;
bi++;
} else {
return false;
}
}
return a2.length === b2.length && result;
}
parseNegate() {
if (this.nonegate)
return;
const pattern = this.pattern;
let negate = false;
let negateOffset = 0;
for (let i2 = 0; i2 < pattern.length && pattern.charAt(i2) === "!"; i2++) {
negate = !negate;
negateOffset++;
}
if (negateOffset)
this.pattern = pattern.slice(negateOffset);
this.negate = negate;
}
// set partial to true to test if, for example,
// "/a/b" matches the start of "/*/b/*/d"
// Partial means, if you run out of file before you run
// out of pattern, then that's fine, as long as all
// the parts match.
matchOne(file, pattern, partial = false) {
const options = this.options;
if (this.isWindows) {
const fileDrive = typeof file[0] === "string" && /^[a-z]:$/i.test(file[0]);
const fileUNC = !fileDrive && file[0] === "" && file[1] === "" && file[2] === "?" && /^[a-z]:$/i.test(file[3]);
const patternDrive = typeof pattern[0] === "string" && /^[a-z]:$/i.test(pattern[0]);
const patternUNC = !patternDrive && pattern[0] === "" && pattern[1] === "" && pattern[2] === "?" && typeof pattern[3] === "string" && /^[a-z]:$/i.test(pattern[3]);
const fdi = fileUNC ? 3 : fileDrive ? 0 : void 0;
const pdi = patternUNC ? 3 : patternDrive ? 0 : void 0;
if (typeof fdi === "number" && typeof pdi === "number") {
const [fd, pd] = [file[fdi], pattern[pdi]];
if (fd.toLowerCase() === pd.toLowerCase()) {
pattern[pdi] = fd;
if (pdi > fdi) {
pattern = pattern.slice(pdi);
} else if (fdi > pdi) {
file = file.slice(fdi);
}
}
}
}
const { optimizationLevel = 1 } = this.options;
if (optimizationLevel >= 2) {
file = this.levelTwoFileOptimize(file);
}
this.debug("matchOne", this, { file, pattern });
this.debug("matchOne", file.length, pattern.length);
for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
this.debug("matchOne loop");
var p2 = pattern[pi];
var f2 = file[fi];
this.debug(pattern, p2, f2);
if (p2 === false) {
return false;
}
if (p2 === GLOBSTAR) {
this.debug("GLOBSTAR", [pattern, p2, f2]);
var fr = fi;
var pr = pi + 1;
if (pr === pl) {
this.debug("** at the end");
for (; fi < fl; fi++) {
if (file[fi] === "." || file[fi] === ".." || !options.dot && file[fi].charAt(0) === ".")
return false;
}
return true;
}
while (fr < fl) {
var swallowee = file[fr];
this.debug("\nglobstar while", file, fr, pattern, pr, swallowee);
if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
this.debug("globstar found match!", fr, fl, swallowee);
return true;
} else {
if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
this.debug("dot detected!", file, fr, pattern, pr);
break;
}
this.debug("globstar swallow a segment, and continue");
fr++;
}
}
if (partial) {
this.debug("\n>>> no match, partial?", file, fr, pattern, pr);
if (fr === fl) {
return true;
}
}
return false;
}
let hit;
if (typeof p2 === "string") {
hit = f2 === p2;
this.debug("string match", p2, f2, hit);
} else {
hit = p2.test(f2);
this.debug("pattern match", p2, f2, hit);
}
if (!hit)
return false;
}
if (fi === fl && pi === pl) {
return true;
} else if (fi === fl) {
return partial;
} else if (pi === pl) {
return fi === fl - 1 && file[fi] === "";
} else {
throw new Error("wtf?");
}
}
braceExpand() {
return braceExpand(this.pattern, this.options);
}
parse(pattern) {
assertValidPattern(pattern);
const options = this.options;
if (pattern === "**")
return GLOBSTAR;
if (pattern === "")
return "";
let m2;
let fastTest = null;
if (m2 = pattern.match(starRE)) {
fastTest = options.dot ? starTestDot : starTest;
} else if (m2 = pattern.match(starDotExtRE)) {
fastTest = (options.nocase ? options.dot ? starDotExtTestNocaseDot : starDotExtTestNocase : options.dot ? starDotExtTestDot : starDotExtTest)(m2[1]);
} else if (m2 = pattern.match(qmarksRE)) {
fastTest = (options.nocase ? options.dot ? qmarksTestNocaseDot : qmarksTestNocase : options.dot ? qmarksTestDot : qmarksTest)(m2);
} else if (m2 = pattern.match(starDotStarRE)) {
fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
} else if (m2 = pattern.match(dotStarRE)) {
fastTest = dotStarTest;
}
const re = AST.fromGlob(pattern, this.options).toMMPattern();
if (fastTest && typeof re === "object") {
Reflect.defineProperty(re, "test", { value: fastTest });
}
return re;
}
makeRe() {
if (this.regexp || this.regexp === false)
return this.regexp;
const set2 = this.set;
if (!set2.length) {
this.regexp = false;
return this.regexp;
}
const options = this.options;
const twoStar = options.noglobstar ? star2 : options.dot ? twoStarDot : twoStarNoDot;
const flags = new Set(options.nocase ? ["i"] : []);
let re = set2.map((pattern) => {
const pp = pattern.map((p2) => {
if (p2 instanceof RegExp) {
for (const f2 of p2.flags.split(""))
flags.add(f2);
}
return typeof p2 === "string" ? regExpEscape2(p2) : p2 === GLOBSTAR ? GLOBSTAR : p2._src;
});
pp.forEach((p2, i2) => {
const next = pp[i2 + 1];
const prev = pp[i2 - 1];
if (p2 !== GLOBSTAR || prev === GLOBSTAR) {
return;
}
if (prev === void 0) {
if (next !== void 0 && next !== GLOBSTAR) {
pp[i2 + 1] = "(?:\\/|" + twoStar + "\\/)?" + next;
} else {
pp[i2] = twoStar;
}
} else if (next === void 0) {
pp[i2 - 1] = prev + "(?:\\/|" + twoStar + ")?";
} else if (next !== GLOBSTAR) {
pp[i2 - 1] = prev + "(?:\\/|\\/" + twoStar + "\\/)" + next;
pp[i2 + 1] = GLOBSTAR;
}
});
return pp.filter((p2) => p2 !== GLOBSTAR).join("/");
}).join("|");
const [open, close] = set2.length > 1 ? ["(?:", ")"] : ["", ""];
re = "^" + open + re + close + "$";
if (this.negate)
re = "^(?!" + re + ").+$";
try {
this.regexp = new RegExp(re, [...flags].join(""));
} catch (ex) {
this.regexp = false;
}
return this.regexp;
}
slashSplit(p2) {
if (this.preserveMultipleSlashes) {
return p2.split("/");
} else if (this.isWindows && /^\/\/[^\/]+/.test(p2)) {
return ["", ...p2.split(/\/+/)];
} else {
return p2.split(/\/+/);
}
}
match(f2, partial = this.partial) {
this.debug("match", f2, this.pattern);
if (this.comment) {
return false;
}
if (this.empty) {
return f2 === "";
}
if (f2 === "/" && partial) {
return true;
}
const options = this.options;
if (this.isWindows) {
f2 = f2.split("\\").join("/");
}
const ff = this.slashSplit(f2);
this.debug(this.pattern, "split", ff);
const set2 = this.set;
this.debug(this.pattern, "set", set2);
let filename = ff[ff.length - 1];
if (!filename) {
for (let i2 = ff.length - 2; !filename && i2 >= 0; i2--) {
filename = ff[i2];
}
}
for (let i2 = 0; i2 < set2.length; i2++) {
const pattern = set2[i2];
let file = ff;
if (options.matchBase && pattern.length === 1) {
file = [filename];
}
const hit = this.matchOne(file, pattern, partial);
if (hit) {
if (options.flipNegate) {
return true;
}
return !this.negate;
}
}
if (options.flipNegate) {
return false;
}
return this.negate;
}
static defaults(def) {
return minimatch.defaults(def).Minimatch;
}
};
minimatch.AST = AST;
minimatch.Minimatch = Minimatch;
minimatch.escape = escape;
minimatch.unescape = unescape;
// src/utils/fs.ts
function isSupportedFileType(path3) {
return path3.split(".").pop().toLowerCase() === "md";
}
function pathMatchesPattern(path3, pattern) {
return path3.startsWith(pattern) || minimatch(path3, pattern);
}
// src/algorithms/osr/osr-note-graph.ts
var OsrNoteGraph = class {
constructor(vaultNoteLinkInfoFinder) {
// Key: targetFilename
// Value: Map
// This is the number of links from sourceFilename to targetFilename
// For simplicity, we just store the filename without the directory or filename extension
this.incomingLinks = {};
this.pageranks = {};
this.vaultNoteLinkInfoFinder = vaultNoteLinkInfoFinder;
this.reset();
}
reset() {
this.incomingLinks = {};
this.pageranks = {};
graph.reset();
}
processLinks(path3) {
if (this.incomingLinks[path3] === void 0) {
this.incomingLinks[path3] = [];
}
const targetLinks = this.vaultNoteLinkInfoFinder.getResolvedTargetLinksForNotePath(path3) || {};
for (const targetPath in targetLinks) {
if (this.incomingLinks[targetPath] === void 0) this.incomingLinks[targetPath] = [];
if (isSupportedFileType(targetPath)) {
const linkCount = targetLinks[targetPath];
this.incomingLinks[targetPath].push({
sourcePath: path3,
linkCount
});
graph.link(path3, targetPath, linkCount);
}
}
}
calcNoteLinkStat(notePath, noteEaseList) {
let linkTotal = 0, linkPGTotal = 0, totalLinkCount = 0;
for (const statObj of this.incomingLinks[notePath] || []) {
const ease = noteEaseList.getEaseByPath(statObj.sourcePath);
if (ease) {
linkTotal += statObj.linkCount * this.pageranks[statObj.sourcePath] * ease;
linkPGTotal += this.pageranks[statObj.sourcePath] * statObj.linkCount;
totalLinkCount += statObj.linkCount;
}
}
const outgoingLinks = this.vaultNoteLinkInfoFinder.getResolvedTargetLinksForNotePath(notePath) || {};
for (const outgoingLink in outgoingLinks) {
const ease = noteEaseList.getEaseByPath(outgoingLink);
const linkCount = outgoingLinks[outgoingLink];
const pageRank = this.pageranks[outgoingLink];
if (ease) {
linkTotal += linkCount * pageRank * ease;
linkPGTotal += pageRank * linkCount;
totalLinkCount += linkCount;
}
}
return { linkTotal, linkPGTotal, totalLinkCount };
}
generatePageRanks() {
graph.rank(0.85, 1e-6, (node, rank2) => {
this.pageranks[node] = rank2 * 1e4;
});
}
};
// src/data-store-algorithm/data-store-algorithm.ts
var DataStoreAlgorithm = class _DataStoreAlgorithm {
static getInstance() {
if (!_DataStoreAlgorithm.instance) {
throw new Error("there is no DataStoreAlgorithm instance.");
}
return _DataStoreAlgorithm.instance;
}
};
// src/data-stores/base/data-store.ts
var DataStore = class _DataStore {
static getInstance() {
if (!_DataStore.instance) {
throw new Error("there is no DataStore instance.");
}
return _DataStore.instance;
}
};
// src/topic-path.ts
var TopicPath = class _TopicPath {
constructor(path3) {
if (path3 == null) throw "null path";
if (path3.some((str) => str.includes("/"))) throw "path entries must not contain '/'";
this.path = path3;
}
get hasPath() {
return this.path.length > 0;
}
get isEmptyPath() {
return !this.hasPath;
}
static get emptyPath() {
return new _TopicPath([]);
}
shift() {
if (this.isEmptyPath) throw "can't shift an empty path";
return this.path.shift();
}
clone() {
return new _TopicPath([...this.path]);
}
formatAsTag() {
if (this.isEmptyPath) throw "Empty path";
const result = "#" + this.path.join("/");
return result;
}
static getTopicPathOfFile(noteFile, settings) {
let deckPath = [];
let result = _TopicPath.emptyPath;
if (settings.convertFoldersToDecks) {
deckPath = noteFile.path.split("/");
deckPath.pop();
if (deckPath.length != 0) {
result = new _TopicPath(deckPath);
}
} else {
const tagList = this.getTopicPathsFromTagList(
noteFile.getAllTagsFromCache()
);
outer: for (const tagToReview of this.getTopicPathsFromTagList(
settings.flashcardTags
)) {
for (const tag of tagList) {
if (tagToReview.isSameOrAncestorOf(tag)) {
result = tag;
break outer;
}
}
}
}
return result;
}
isSameOrAncestorOf(topicPath) {
if (this.isEmptyPath) return topicPath.isEmptyPath;
if (this.path.length > topicPath.path.length) return false;
for (let i2 = 0; i2 < this.path.length; i2++) {
if (this.path[i2] != topicPath.path[i2]) return false;
}
return true;
}
static getTopicPathFromCardText(cardText) {
var _a;
const path3 = (_a = cardText.trimStart().match(OBSIDIAN_TAG_AT_STARTOFLINE_REGEX)) == null ? void 0 : _a.slice(-1)[0];
return (path3 == null ? void 0 : path3.length) > 0 ? _TopicPath.getTopicPathFromTag(path3) : null;
}
static getTopicPathsFromTagList(tagList) {
const result = [];
for (const tag of tagList) {
if (this.isValidTag(tag)) result.push(_TopicPath.getTopicPathFromTag(tag));
}
return result;
}
static isValidTag(tag) {
if (tag == null || tag.length == 0) return false;
if (tag[0] != "#") return false;
if (tag.length == 1) return false;
return true;
}
static getTopicPathFromTag(tag) {
if (tag == null || tag.length == 0) throw "Null/empty tag";
if (tag[0] != "#") throw "Tag must start with #";
if (tag.length == 1) throw "Invalid tag";
const path3 = tag.replace("#", "").split("/").filter((str) => str);
return new _TopicPath(path3);
}
static getFolderPathFromFilename(noteFile, settings) {
let result = _TopicPath.emptyPath;
if (settings.convertFoldersToDecks) {
const deckPath = noteFile.path.split("/");
deckPath.pop();
if (deckPath.length != 0) {
result = new _TopicPath(deckPath);
}
}
return result;
}
};
var TopicPathList = class _TopicPathList {
constructor(list, lineNum = null) {
if (list == null) throw "TopicPathList null";
this.list = list;
this.lineNum = lineNum;
}
get length() {
return this.list.length;
}
isAnyElementSameOrAncestorOf(topicPath) {
return this.list.some((item) => item.isSameOrAncestorOf(topicPath));
}
formatPsv() {
return this.format("|");
}
format(sep2) {
return this.list.map((topicPath) => topicPath.formatAsTag()).join(sep2);
}
static empty() {
return new _TopicPathList([]);
}
static fromPsv(str, lineNum) {
const result = _TopicPathList.convertTagListToTopicPathList(str.split("|"));
result.lineNum = lineNum;
return result;
}
//
// tagList is a list of tags such as:
// ["#flashcards/computing", "#boring-stuff", "#news-worthy"]
// validTopicPathList is a list of valid tags, such as those from settings.flashcardTags,E.g.
// ["#flashcards"]
//
// This returns a filtered version of tagList, containing only topic paths that are considered valid.
// Validity is defined as "isAnyElementSameOrAncestorOf", and "#flashcards" is considered the ancestor of
// "#flashcards/computing".
//
// Therefore this would return:
// "#flashcards/computing" (but not "#boring-stuff" or "#news-worthy")
//
static filterValidTopicPathsFromTagList(list, validTopicPathList, lineNum = null) {
const result = [];
for (const tag of list.list) {
if (validTopicPathList.isAnyElementSameOrAncestorOf(tag)) result.push(tag);
}
return new _TopicPathList(result, lineNum);
}
static convertTagListToTopicPathList(tagList) {
const result = [];
for (const tag of tagList) {
if (TopicPath.isValidTag(tag)) result.push(TopicPath.getTopicPathFromTag(tag));
}
return new _TopicPathList(result);
}
};
var TopicPathWithWs = class {
constructor(topicPath, preWhitespace, postWhitespace) {
if (!topicPath || topicPath.isEmptyPath) throw "topicPath null";
this.topicPath = topicPath;
this.preWhitespace = preWhitespace;
this.postWhitespace = postWhitespace;
}
formatWithWs() {
return `${this.preWhitespace}${this.topicPath.formatAsTag()}${this.postWhitespace}`;
}
};
// src/flashcard-review-sequencer.ts
var DeckStats = class {
constructor(dueCount, newCount, totalCount) {
this.dueCount = dueCount;
this.newCount = newCount;
this.totalCount = totalCount;
}
};
var FlashcardReviewSequencer = class {
constructor(reviewMode, cardSequencer, settings, srsAlgorithm, questionPostponementList, dueDateFlashcardHistogram) {
this.reviewMode = reviewMode;
this.cardSequencer = cardSequencer;
this.settings = settings;
this.srsAlgorithm = srsAlgorithm;
this.questionPostponementList = questionPostponementList;
this.dueDateFlashcardHistogram = dueDateFlashcardHistogram;
}
get hasCurrentCard() {
return this.cardSequencer.currentCard != null;
}
get currentCard() {
return this.cardSequencer.currentCard;
}
get currentQuestion() {
var _a;
return (_a = this.currentCard) == null ? void 0 : _a.question;
}
get currentDeck() {
return this.cardSequencer.currentDeck;
}
get currentNote() {
return this.currentQuestion.note;
}
// originalDeckTree isn't modified by the review process
// Only remainingDeckTree
setDeckTree(originalDeckTree, remainingDeckTree) {
this.cardSequencer.setBaseDeck(remainingDeckTree);
this._originalDeckTree = originalDeckTree;
this.remainingDeckTree = remainingDeckTree;
this.setCurrentDeck(TopicPath.emptyPath);
}
setCurrentDeck(topicPath) {
this.cardSequencer.setIteratorTopicPath(topicPath);
this.cardSequencer.nextCard();
}
get originalDeckTree() {
return this._originalDeckTree;
}
getDeckStats(topicPath) {
const totalCount = this._originalDeckTree.getDeck(topicPath).getDistinctCardCount(2 /* All */, true);
const remainingDeck = this.remainingDeckTree.getDeck(topicPath);
const newCount = remainingDeck.getDistinctCardCount(0 /* NewCard */, true);
const dueCount = remainingDeck.getDistinctCardCount(1 /* DueCard */, true);
return new DeckStats(dueCount, newCount, totalCount);
}
skipCurrentCard() {
this.cardSequencer.deleteCurrentQuestionFromAllDecks();
}
deleteCurrentCard() {
this.cardSequencer.deleteCurrentCardFromAllDecks();
}
async processReview(response) {
switch (this.reviewMode) {
case 1 /* Review */:
await this.processReviewReviewMode(response);
break;
case 0 /* Cram */:
await this.processReviewCramMode(response);
break;
}
}
async processReviewReviewMode(response) {
if (response != 3 /* Reset */ || this.currentCard.hasSchedule) {
const oldSchedule = this.currentCard.scheduleInfo;
this.currentCard.scheduleInfo = this.determineCardSchedule(response, this.currentCard);
await DataStore.getInstance().questionWriteSchedule(this.currentQuestion);
if (oldSchedule) {
const today = globalDateProvider.today.valueOf();
const nDays = Math.ceil(
(oldSchedule.dueDateAsUnix - today) / TICKS_PER_DAY
);
this.dueDateFlashcardHistogram.decrement(nDays);
}
this.dueDateFlashcardHistogram.increment(this.currentCard.scheduleInfo.interval);
}
if (response == 3 /* Reset */) {
this.cardSequencer.moveCurrentCardToEndOfList();
this.cardSequencer.nextCard();
} else {
if (this.settings.burySiblingCards) {
await this.burySiblingCards();
this.cardSequencer.deleteCurrentQuestionFromAllDecks();
} else {
this.deleteCurrentCard();
}
}
}
async burySiblingCards() {
const remaining = this.currentDeck.getQuestionCardCount(this.currentQuestion);
if (remaining > 1) {
this.questionPostponementList.add(this.currentQuestion);
await this.questionPostponementList.write();
}
}
async processReviewCramMode(response) {
if (response == 0 /* Easy */) this.deleteCurrentCard();
else {
this.cardSequencer.moveCurrentCardToEndOfList();
this.cardSequencer.nextCard();
}
}
determineCardSchedule(response, card) {
let result;
if (response == 3 /* Reset */) {
result = this.srsAlgorithm.cardGetResetSchedule();
} else {
if (card.hasSchedule) {
result = this.srsAlgorithm.cardCalcUpdatedSchedule(
response,
card.scheduleInfo,
this.dueDateFlashcardHistogram
);
} else {
const currentNote = card.question.note;
result = this.srsAlgorithm.cardGetNewSchedule(
response,
currentNote.filePath,
this.dueDateFlashcardHistogram
);
}
}
return result;
}
async updateCurrentQuestionText(text) {
const q2 = this.currentQuestion.questionText;
q2.actualQuestion = text;
await DataStore.getInstance().questionWrite(this.currentQuestion);
}
};
// src/deck.ts
var Deck2 = class _Deck {
constructor(deckName, parent) {
this.deckName = deckName;
this.newFlashcards = [];
this.dueFlashcards = [];
this.subdecks = [];
this.parent = parent;
}
getCardCount(cardListType, includeSubdeckCounts) {
let result = 0;
if (cardListType == 0 /* NewCard */ || cardListType == 2 /* All */)
result += this.newFlashcards.length;
if (cardListType == 1 /* DueCard */ || cardListType == 2 /* All */)
result += this.dueFlashcards.length;
if (includeSubdeckCounts) {
for (const deck of this.subdecks) {
result += deck.getCardCount(cardListType, includeSubdeckCounts);
}
}
return result;
}
getDistinctCardCount(cardListType, includeSubdeckCounts) {
const cardList = this.getFlattenedCardArray(cardListType, includeSubdeckCounts);
const distinctCardSet = new Set(cardList);
return distinctCardSet.size;
}
getFlattenedCardArray(cardListType, includeSubdeckCounts) {
let result = [];
switch (cardListType) {
case 0 /* NewCard */:
result = this.newFlashcards;
break;
case 1 /* DueCard */:
result = this.dueFlashcards;
break;
case 2 /* All */:
result = this.newFlashcards.concat(this.dueFlashcards);
}
if (includeSubdeckCounts) {
for (const subdeck of this.subdecks) {
result = result.concat(
subdeck.getFlattenedCardArray(cardListType, includeSubdeckCounts)
);
}
}
return result;
}
// Returns a count of the number of this question's cards are present in this deck.
// (The returned value would be <= question.cards.length)
getQuestionCardCount(question) {
let result = 0;
result += this.getQuestionCardCountForCardListType(question, this.newFlashcards);
result += this.getQuestionCardCountForCardListType(question, this.dueFlashcards);
return result;
}
getQuestionCardCountForCardListType(question, cards) {
let result = 0;
for (let i2 = 0; i2 < cards.length; i2++) {
if (Object.is(question, cards[i2].question)) result++;
}
return result;
}
static get emptyDeck() {
return new _Deck("Root", null);
}
get isRootDeck() {
return this.parent == null;
}
getDeckByTopicTag(tag) {
return this.getDeck(TopicPath.getTopicPathFromTag(tag));
}
getDeck(topicPath) {
return this._getOrCreateDeck(topicPath, false);
}
getOrCreateDeck(topicPath) {
return this._getOrCreateDeck(topicPath, true);
}
_getOrCreateDeck(topicPath, createAllowed) {
if (!topicPath.hasPath) {
return this;
}
const t3 = topicPath.clone();
const deckName = t3.shift();
for (const subdeck of this.subdecks) {
if (deckName === subdeck.deckName) {
return subdeck._getOrCreateDeck(t3, createAllowed);
}
}
let result = null;
if (createAllowed) {
const subdeck = new _Deck(
deckName,
this
/* parent */
);
this.subdecks.push(subdeck);
result = subdeck._getOrCreateDeck(t3, createAllowed);
}
return result;
}
getTopicPath() {
const list = [];
let deck = this;
while (!deck.isRootDeck) {
list.push(deck.deckName);
deck = deck.parent;
}
return new TopicPath(list.reverse());
}
getRootDeck() {
let deck = this;
while (!deck.isRootDeck) {
deck = deck.parent;
}
return deck;
}
getCard(index, cardListType) {
const cardList = this.getCardListForCardType(cardListType);
return cardList[index];
}
getCardListForCardType(cardListType) {
return cardListType == 1 /* DueCard */ ? this.dueFlashcards : this.newFlashcards;
}
appendCard(topicPathList, cardObj) {
if (topicPathList.list.length == 0) {
this.appendCardToRootDeck(cardObj);
} else {
for (const topicPath of topicPathList.list) {
this.appendCardSingleTopic(topicPath, cardObj);
}
}
}
appendCardToRootDeck(cardObj) {
this.appendCardSingleTopic(TopicPath.emptyPath, cardObj);
}
appendCardSingleTopic(topicPath, cardObj) {
const deck = this.getOrCreateDeck(topicPath);
const cardList = deck.getCardListForCardType(cardObj.cardListType);
cardList.push(cardObj);
}
// The question lists all the topics in which this card is included.
// The topics are relative to the base deck, and this method must be called on that deck
deleteQuestionFromAllDecks(question, exceptionIfMissing) {
for (const card of question.cards) {
this.deleteCardFromAllDecks(card, exceptionIfMissing);
}
}
deleteQuestion(question, exceptionIfMissing) {
for (const card of question.cards) {
this.deleteCardFromThisDeck(card, exceptionIfMissing);
}
}
// The card's question lists all the topics in which this card is included.
// The topics are relative to the base deck, and this method must be called on that deck
deleteCardFromAllDecks(card, exceptionIfMissing) {
for (const topicPath of card.question.topicPathList.list) {
const deck = this.getDeck(topicPath);
deck.deleteCardFromThisDeck(card, exceptionIfMissing);
}
}
deleteCardFromThisDeck(card, exceptionIfMissing) {
const newIdx = this.newFlashcards.indexOf(card);
if (newIdx != -1) this.newFlashcards.splice(newIdx, 1);
const dueIdx = this.dueFlashcards.indexOf(card);
if (dueIdx != -1) this.dueFlashcards.splice(dueIdx, 1);
if (newIdx == -1 && dueIdx == -1 && exceptionIfMissing) {
throw `deleteCardFromThisDeck: Card: ${card.front} not found in deck: ${this.deckName}`;
}
}
deleteCardAtIndex(index, cardListType) {
const cardList = this.getCardListForCardType(cardListType);
cardList.splice(index, 1);
}
toDeckArray() {
const result = [];
result.push(this);
for (const subdeck of this.subdecks) {
result.push(...subdeck.toDeckArray());
}
return result;
}
sortSubdecksList() {
this.subdecks.sort((a2, b2) => {
if (a2.deckName < b2.deckName) {
return -1;
} else if (a2.deckName > b2.deckName) {
return 1;
}
return 0;
});
for (const deck of this.subdecks) {
deck.sortSubdecksList();
}
}
debugLogToConsole(desc = null, indent = 0) {
let str = desc != null ? `${desc}: ` : "";
console.log(str += this.toString(indent));
}
toString(indent = 0) {
let result = "";
let indentStr = " ".repeat(indent * 4);
result += `${indentStr}${this.deckName}\r
`;
indentStr += " ";
for (let i2 = 0; i2 < this.newFlashcards.length; i2++) {
const card = this.newFlashcards[i2];
result += `${indentStr}New: ${i2}: ${card.front}::${card.back}\r
`;
}
for (let i2 = 0; i2 < this.dueFlashcards.length; i2++) {
const card = this.dueFlashcards[i2];
const s2 = card.isDue ? "Due" : "Not due";
result += `${indentStr}${s2}: ${i2}: ${card.front}::${card.back}\r
`;
}
for (const subdeck of this.subdecks) {
result += subdeck.toString(indent + 1);
}
return result;
}
clone() {
return this.copyWithCardFilter(() => true);
}
copyWithCardFilter(predicate, parent = null) {
const result = new _Deck(this.deckName, parent);
result.newFlashcards = [...this.newFlashcards.filter((card) => predicate(card))];
result.dueFlashcards = [...this.dueFlashcards.filter((card) => predicate(card))];
for (const s2 of this.subdecks) {
const newParent = result;
const newDeck = s2.copyWithCardFilter(predicate, newParent);
result.subdecks.push(newDeck);
}
return result;
}
static otherListType(cardListType) {
let result;
if (cardListType == 0 /* NewCard */) result = 1 /* DueCard */;
else if (cardListType == 1 /* DueCard */) result = 0 /* NewCard */;
else throw "Invalid cardListType";
return result;
}
};
var DeckTreeFilter = class {
static filterForReviewableCards(reviewableDeckTree) {
return reviewableDeckTree.copyWithCardFilter((card) => !card.question.hasEditLaterTag);
}
static filterForRemainingCards(questionPostponementList, deckTree, reviewMode) {
return deckTree.copyWithCardFilter(
(card) => (reviewMode == 0 /* Cram */ || card.isNew || card.isDue) && !questionPostponementList.includes(card.question)
);
}
};
// src/utils/types.ts
function getTypedObjectEntries(obj) {
return Object.entries(obj);
}
var getKeysPreserveType = Object.keys;
function mapRecord(record, transform) {
return Object.fromEntries(
Object.entries(record).map(([key, value]) => transform(key, value))
);
}
// src/utils/numbers.ts
var ValueCountDict = class {
constructor() {
this.dict = {};
}
// Record
clearCountIfMissing(value) {
if (!this.hasValue(value)) this.dict[value] = 0;
}
hasValue(value) {
return Object.prototype.hasOwnProperty.call(this.dict, value);
}
incrementCount(value) {
this.clearCountIfMissing(value);
this.dict[value]++;
}
getMaxValue() {
return Math.max(...getKeysPreserveType(this.dict)) || 0;
}
getTotalOfValueMultiplyCount() {
const v2 = getTypedObjectEntries(this.dict).map(([value, count]) => value * count).reduce((a2, b2) => a2 + b2, 0) || 0;
return v2;
}
};
var RandomNumberProvider = class {
getInteger(lowerBound, upperBound) {
const range = upperBound - lowerBound + 1;
return Math.floor(Math.random() * range) + lowerBound;
}
};
var StaticRandomNumberProvider = class {
getInteger(lowerBound, upperBound) {
if (lowerBound != this.expectedLowerBound || upperBound != this.expectedUpperBound)
throw `lowerBound: A${lowerBound}/E${this.expectedLowerBound}, upperBound: A${upperBound}/E${this.expectedUpperBound}`;
return this.next;
}
};
var WeightedRandomNumber = class _WeightedRandomNumber {
constructor(provider) {
this.provider = provider;
}
static create() {
return new _WeightedRandomNumber(globalRandomNumberProvider);
}
// weights is a dictionary:
// first number - a key that can be returned
// second number - the "bucket size" - this is a weight that influences the probability of the
// first number being returned
//
// returns:
// first number - one of the keys from the weights parameter
// second number - an "index" value; 0 <= index < bucketSize
getRandomValues(weights) {
const total = _WeightedRandomNumber.calcTotalOfCount(weights);
if (Object.values(weights).some((i2) => !Number.isInteger(i2) || i2 < 0))
throw "All weights must be positive integers";
const v2 = this.provider.getInteger(0, total - 1);
let x2 = 0;
for (const kvp in weights) {
const [value, count] = [Number(kvp), weights[kvp]];
if (v2 < x2 + count) {
const index = v2 - x2;
return [value, index];
}
x2 += count;
}
throw "";
}
static calcTotalOfCount(weights) {
const total = getTypedObjectEntries(weights).map(([_2, count]) => count).reduce((a2, b2) => a2 + b2, 0) || 0;
return total;
}
};
var globalRandomNumberProvider = new RandomNumberProvider();
var staticRandomNumberProvider = new StaticRandomNumberProvider();
// src/deck-tree-iterator.ts
var CardOrder = /* @__PURE__ */ ((CardOrder2) => {
CardOrder2[CardOrder2["NewFirstSequential"] = 0] = "NewFirstSequential";
CardOrder2[CardOrder2["NewFirstRandom"] = 1] = "NewFirstRandom";
CardOrder2[CardOrder2["DueFirstSequential"] = 2] = "DueFirstSequential";
CardOrder2[CardOrder2["DueFirstRandom"] = 3] = "DueFirstRandom";
CardOrder2[CardOrder2["EveryCardRandomDeckAndCard"] = 4] = "EveryCardRandomDeckAndCard";
return CardOrder2;
})(CardOrder || {});
var DeckOrder = /* @__PURE__ */ ((DeckOrder2) => {
DeckOrder2[DeckOrder2["PrevDeckComplete_Sequential"] = 0] = "PrevDeckComplete_Sequential";
DeckOrder2[DeckOrder2["PrevDeckComplete_Random"] = 1] = "PrevDeckComplete_Random";
return DeckOrder2;
})(DeckOrder || {});
var SingleDeckIterator = class _SingleDeckIterator {
get hasCurrentCard() {
return this.cardIdx != null;
}
get currentCard() {
let result = null;
if (this.cardIdx != null) result = this.deck.getCard(this.cardIdx, this.cardListType);
return result;
}
constructor(iteratorOrder) {
this.iteratorOrder = iteratorOrder;
this.preferredCardListType = _SingleDeckIterator.getCardListTypeForIterator(
this.iteratorOrder
);
this.weightedRandomNumber = WeightedRandomNumber.create();
}
setDeck(deck) {
this.deck = deck;
this.setCardListType(null);
}
//
// 0 <= cardIndex < newFlashcards.length + dueFlashcards.length
//
setNewOrDueCardIdx(cardIndex) {
let cardListType = 0 /* NewCard */;
let index = cardIndex;
if (cardIndex >= this.deck.newFlashcards.length) {
cardListType = 1 /* DueCard */;
index = cardIndex - this.deck.newFlashcards.length;
}
this.setCardListType(cardListType, index);
}
setCardListType(cardListType, cardIdx = null) {
this.cardListType = cardListType;
this.cardIdx = cardIdx;
}
nextCard() {
if (this.iteratorOrder.cardOrder == 4 /* EveryCardRandomDeckAndCard */) {
this.nextRandomCard();
} else {
if (this.cardListType == null) {
this.setCardListType(this.preferredCardListType);
}
if (!this.nextCardWithinCurrentList()) {
if (this.cardListType == this.preferredCardListType) {
this.setCardListType(Deck2.otherListType(this.cardListType));
if (!this.nextCardWithinCurrentList()) {
this.setCardListType(null);
}
} else {
this.cardIdx = null;
}
}
}
return this.cardIdx != null;
}
nextRandomCard() {
const newCount = this.deck.newFlashcards.length;
const dueCount = this.deck.dueFlashcards.length;
if (newCount + dueCount > 0) {
const weights = {};
if (newCount > 0) weights[0 /* NewCard */] = newCount;
if (dueCount > 0) weights[1 /* DueCard */] = dueCount;
const [cardListType, index] = this.weightedRandomNumber.getRandomValues(weights);
this.setCardListType(cardListType, index);
} else {
this.setCardListType(null);
}
}
nextCardWithinCurrentList() {
const cardList = this.deck.getCardListForCardType(this.cardListType);
const result = cardList.length > 0;
if (result) {
switch (this.iteratorOrder.cardOrder) {
case 2 /* DueFirstSequential */:
case 0 /* NewFirstSequential */:
this.cardIdx = 0;
break;
case 3 /* DueFirstRandom */:
case 1 /* NewFirstRandom */:
this.cardIdx = globalRandomNumberProvider.getInteger(0, cardList.length - 1);
break;
}
}
return result;
}
moveCurrentCardToEndOfList() {
this.ensureCurrentCard();
const cardList = this.deck.getCardListForCardType(this.cardListType);
if (cardList.length <= 1) return;
const card = this.currentCard;
this.deck.deleteCardAtIndex(this.cardIdx, this.cardListType);
this.deck.appendCardToRootDeck(card);
this.setNoCurrentCard();
}
setNoCurrentCard() {
this.cardIdx = null;
}
ensureCurrentCard() {
if (this.cardIdx == null || this.cardListType == null) throw "no current card";
}
static getCardListTypeForIterator(iteratorOrder) {
let result = null;
switch (iteratorOrder.cardOrder) {
case 3 /* DueFirstRandom */:
case 2 /* DueFirstSequential */:
result = 1 /* DueCard */;
break;
case 1 /* NewFirstRandom */:
case 0 /* NewFirstSequential */:
result = 0 /* NewCard */;
break;
}
return result;
}
};
var DeckTreeIterator = class _DeckTreeIterator {
get hasCurrentCard() {
return this.deckIdx != null && this.singleDeckIterator.hasCurrentCard;
}
get currentTopicPath() {
var _a;
return (_a = this.currentDeck) == null ? void 0 : _a.getTopicPath();
}
get currentDeck() {
if (this.deckIdx == null) return null;
return this.deckArray[this.deckIdx];
}
get currentCard() {
let result = null;
if (this.deckIdx != null && this.singleDeckIterator.hasCurrentCard)
result = this.singleDeckIterator.currentCard;
return result;
}
get currentQuestion() {
var _a;
return (_a = this.currentCard) == null ? void 0 : _a.question;
}
constructor(iteratorOrder, baseDeckTree) {
this.singleDeckIterator = new SingleDeckIterator(iteratorOrder);
this.iteratorOrder = iteratorOrder;
this.weightedRandomNumber = WeightedRandomNumber.create();
this.setBaseDeck(baseDeckTree);
}
setBaseDeck(baseDeck) {
this.baseDeckTree = baseDeck;
this.singleDeckIterator.setNoCurrentCard();
}
setIteratorTopicPath(topicPath) {
const iteratorDeck = this.baseDeckTree.getDeck(topicPath);
this.deckArray = _DeckTreeIterator.filterForDecksWithCards(iteratorDeck.toDeckArray());
this.setDeckIdx(null);
}
static filterForDecksWithCards(sourceArray) {
const result = [];
for (let idx = 0; idx < sourceArray.length; idx++) {
const deck = sourceArray[idx];
const hasAnyCards = deck.getCardCount(2 /* All */, false) > 0;
if (hasAnyCards) {
result.push(deck);
}
}
return result;
}
setDeckIdx(deckIdx) {
this.deckIdx = deckIdx;
if (deckIdx != null) this.singleDeckIterator.setDeck(this.deckArray[deckIdx]);
}
nextCard() {
let result = false;
if (this.hasCurrentCard) {
this.baseDeckTree.deleteCardFromAllDecks(this.currentCard, true);
}
if (this.iteratorOrder.cardOrder == 4 /* EveryCardRandomDeckAndCard */) {
result = this.nextCardEveryCardRandomDeck();
} else {
if (this.deckIdx == null) {
this.chooseNextDeck(true);
}
while (this.deckIdx < this.deckArray.length) {
if (this.singleDeckIterator.nextCard()) {
result = true;
break;
}
this.chooseNextDeck(false);
}
}
if (!result) this.deckIdx = null;
return result;
}
chooseNextDeck(firstTime) {
switch (this.iteratorOrder.deckOrder) {
case 0 /* PrevDeckComplete_Sequential */:
this.deckIdx = firstTime ? 0 : this.deckIdx + 1;
break;
case 1 /* PrevDeckComplete_Random */: {
const weights = {};
let hasDeck = false;
for (let i2 = 0; i2 < this.deckArray.length; i2++) {
if (this.deckArray[i2].getCardCount(2 /* All */, false)) {
weights[i2] = 1;
hasDeck = true;
}
}
if (hasDeck) {
const [deckIdx, _2] = this.weightedRandomNumber.getRandomValues(weights);
this.deckIdx = deckIdx;
} else {
this.deckIdx = this.deckArray.length;
}
break;
}
}
if (this.deckIdx < this.deckArray.length) {
this.singleDeckIterator.setDeck(this.deckArray[this.deckIdx]);
}
}
nextCardEveryCardRandomDeck() {
const weights = {};
for (let i2 = 0; i2 < this.deckArray.length; i2++) {
const cardCount = this.deckArray[i2].getCardCount(2 /* All */, false);
if (cardCount) {
weights[i2] = cardCount;
}
}
if (Object.keys(weights).length == 0) return false;
const [deckIdx, cardIdx] = this.weightedRandomNumber.getRandomValues(weights);
this.setDeckIdx(deckIdx);
this.singleDeckIterator.setNewOrDueCardIdx(cardIdx);
return true;
}
deleteCurrentQuestionFromAllDecks() {
this.singleDeckIterator.ensureCurrentCard();
this.baseDeckTree.deleteQuestionFromAllDecks(this.currentQuestion, false);
this.singleDeckIterator.setNoCurrentCard();
return this.nextCard();
}
deleteCurrentCardFromAllDecks() {
this.singleDeckIterator.ensureCurrentCard();
this.baseDeckTree.deleteCardFromAllDecks(this.currentCard, true);
this.singleDeckIterator.setNoCurrentCard();
return this.nextCard();
}
moveCurrentCardToEndOfList() {
this.singleDeckIterator.moveCurrentCardToEndOfList();
}
removeCurrentDeckIfEmpty() {
if (this.currentDeck.getCardCount(2 /* All */, false) == 0) {
this.deckArray.splice(this.deckIdx, 1);
if (this.deckIdx < this.deckArray.length) this.setDeckIdx(this.deckIdx);
}
}
};
// src/stats.ts
var Stats = class {
constructor() {
this.eases = new ValueCountDict();
this.intervals = new ValueCountDict();
this.delayedDays = new ValueCountDict();
this.newCount = 0;
this.youngCount = 0;
this.matureCount = 0;
}
get totalCount() {
return this.youngCount + this.matureCount;
}
incrementNew() {
this.newCount++;
}
update(delayedDays, interval, ease) {
this.intervals.incrementCount(interval);
this.eases.incrementCount(ease);
this.delayedDays.incrementCount(delayedDays);
if (interval >= 32) {
this.matureCount++;
} else {
this.youngCount++;
}
}
getMaxInterval() {
return this.intervals.getMaxValue();
}
getAverageInterval() {
return this.intervals.getTotalOfValueMultiplyCount() / this.totalCount;
}
getAverageEases() {
return this.eases.getTotalOfValueMultiplyCount() / this.totalCount;
}
};
// src/deck-tree-stats-calculator.ts
var DeckTreeStatsCalculator = class {
calculate(deckTree) {
const iteratorOrder = {
deckOrder: 0 /* PrevDeckComplete_Sequential */,
cardOrder: 2 /* DueFirstSequential */
};
const iterator = new DeckTreeIterator(iteratorOrder, deckTree.clone());
const result = new Stats();
iterator.setIteratorTopicPath(TopicPath.emptyPath);
while (iterator.nextCard()) {
const card = iterator.currentCard;
if (card.hasSchedule) {
const schedule = card.scheduleInfo;
result.update(
schedule.delayedBeforeReviewDaysInt(),
schedule.interval,
schedule.latestEase
);
} else {
result.incrementNew();
}
}
return result;
}
};
// src/due-date-histogram.ts
var _DueDateHistogram = class _DueDateHistogram {
constructor(rec = null) {
// Key - # of days in future
// Value - Count of notes due
this.dueDatesMap = /* @__PURE__ */ new Map();
this.dueDatesMap = /* @__PURE__ */ new Map();
if (rec != null) {
Object.entries(rec).forEach(([key, value]) => {
this.dueDatesMap.set(Number(key), value);
});
}
}
get dueNotesCount() {
let result = 0;
if (this.dueDatesMap.has(_DueDateHistogram.dueNowNDays))
result = this.dueDatesMap.get(_DueDateHistogram.dueNowNDays);
return result;
}
hasEntryForDays(days) {
return this.dueDatesMap.has(days);
}
set(days, value) {
this.dueDatesMap.set(days, value);
}
get(days) {
return this.dueDatesMap.get(days);
}
increment(days) {
let value = 0;
if (this.dueDatesMap.has(days)) {
value = this.dueDatesMap.get(days);
}
this.dueDatesMap.set(days, value + 1);
}
decrement(days) {
let value = 0;
if (this.dueDatesMap.has(days)) value = this.dueDatesMap.get(days);
if (value > 0) {
this.dueDatesMap.set(days, value - 1);
}
}
findLeastUsedIntervalOverRange(originalInterval, fuzz) {
if (!this.hasEntryForDays(originalInterval)) {
return originalInterval;
}
let interval = originalInterval;
outer: for (let i2 = 1; i2 <= fuzz; i2++) {
for (const ivl of [originalInterval - i2, originalInterval + i2]) {
if (!this.hasEntryForDays(ivl)) {
interval = ivl;
break outer;
}
if (this.dueDatesMap.get(ivl) < this.dueDatesMap.get(interval)) interval = ivl;
}
}
return interval;
}
};
// The key for dueDatesNotes is the number of days after today
// therefore the key to lookup how many cards are due today is 0
_DueDateHistogram.dueNowNDays = 0;
var DueDateHistogram = _DueDateHistogram;
var NoteDueDateHistogram = class extends DueDateHistogram {
calculateFromReviewDecksAndSort(reviewDecks, osrNoteGraph) {
this.dueDatesMap = /* @__PURE__ */ new Map();
const today = globalDateProvider.today.valueOf();
reviewDecks.forEach((reviewDeck) => {
reviewDeck.scheduledNotes.forEach((scheduledNote) => {
const nDays = Math.ceil((scheduledNote.dueUnix - today) / TICKS_PER_DAY);
this.increment(nDays);
});
reviewDeck.sortNotesByDateAndImportance(osrNoteGraph.pageranks);
});
}
};
var CardDueDateHistogram = class extends DueDateHistogram {
calculateFromDeckTree(deckTree) {
this.dueDatesMap = /* @__PURE__ */ new Map();
const iteratorOrder = {
deckOrder: 0 /* PrevDeckComplete_Sequential */,
cardOrder: 2 /* DueFirstSequential */
};
const today = globalDateProvider.today.valueOf();
const iterator = new DeckTreeIterator(iteratorOrder, deckTree.clone());
iterator.setIteratorTopicPath(TopicPath.emptyPath);
while (iterator.nextCard()) {
const card = iterator.currentCard;
if (card.hasSchedule) {
const scheduledCard = card.scheduleInfo;
const nDays = Math.ceil(
(scheduledCard.dueDateAsUnix - today) / TICKS_PER_DAY
);
this.increment(nDays);
}
}
}
};
// src/file.ts
var import_obsidian2 = require("obsidian");
// src/utils/strings.ts
function literalStringReplace(text, searchStr, replacementStr) {
let result = text;
const startIdx = text.indexOf(searchStr);
if (startIdx >= 0) {
const startStr = text.substring(0, startIdx);
const endIdx = startIdx + searchStr.length;
const endStr = text.substring(endIdx);
result = startStr + replacementStr + endStr;
}
return result;
}
function cyrb53(str, seed = 0) {
let h12 = 3735928559 ^ seed, h22 = 1103547991 ^ seed;
for (let i2 = 0, ch; i2 < str.length; i2++) {
ch = str.charCodeAt(i2);
h12 = Math.imul(h12 ^ ch, 2654435761);
h22 = Math.imul(h22 ^ ch, 1597334677);
}
h12 = Math.imul(h12 ^ h12 >>> 16, 2246822507) ^ Math.imul(h22 ^ h22 >>> 13, 3266489909);
h22 = Math.imul(h22 ^ h22 >>> 16, 2246822507) ^ Math.imul(h12 ^ h12 >>> 13, 3266489909);
return (4294967296 * (2097151 & h22) + (h12 >>> 0)).toString(16);
}
function convertToStringOrEmpty(v2) {
let result = "";
if (v2 != null && v2 != void 0) {
result = v2 + "";
}
return result;
}
function splitTextIntoLineArray(text) {
return text.replaceAll(/\r\n|\r/g, "\n").split("\n");
}
function stringTrimStart(str) {
if (!str) {
return ["", ""];
}
const trimmed = str.trimStart();
const wsCount = str.length - trimmed.length;
const ws = str.substring(0, wsCount);
return [ws, trimmed];
}
function splitNoteIntoFrontmatterAndContent(str) {
const lines = splitTextIntoLineArray(str);
let lineIndex = 0;
let hasFrontmatter = false;
do {
if (lineIndex === 0 && lines[lineIndex] === "---") {
hasFrontmatter = true;
} else if (hasFrontmatter && lines[lineIndex] === "---") {
hasFrontmatter = false;
lineIndex++;
}
if (hasFrontmatter) {
lineIndex++;
}
} while (hasFrontmatter && lineIndex < lines.length);
if (hasFrontmatter) {
lineIndex = 0;
}
const frontmatter = lines.slice(0, lineIndex).join("\n");
const emptyLines = lineIndex > 0 ? Array(lineIndex).join(".").split(".") : [];
const content = emptyLines.concat(lines.slice(lineIndex)).join("\n");
return [frontmatter, content];
}
function findLineIndexOfSearchStringIgnoringWs(lines, searchString) {
let result = -1;
for (let i2 = 0; i2 < lines.length; i2++) {
if (lines[i2].trim() == searchString) {
result = i2;
break;
}
}
return result;
}
function parseObsidianFrontmatterTag(tagStr) {
const result = [];
if (tagStr) {
const tagStrList = tagStr.split(",");
for (const tag of tagStrList) {
if (tag !== "") {
result.push(tag.startsWith("#") ? tag : "#" + tag);
}
}
}
return result;
}
var MultiLineTextFinder = class _MultiLineTextFinder {
static findAndReplace(sourceText, searchText, replacementText) {
let result = null;
if (sourceText.includes(searchText)) {
result = literalStringReplace(sourceText, searchText, replacementText);
} else {
const sourceTextArray = splitTextIntoLineArray(sourceText);
const searchTextArray = splitTextIntoLineArray(searchText);
const lineNo = _MultiLineTextFinder.find(
sourceTextArray,
searchTextArray
);
if (lineNo !== null) {
const replacementTextArray = splitTextIntoLineArray(replacementText);
const linesToRemove = searchTextArray.length;
sourceTextArray.splice(lineNo, linesToRemove, ...replacementTextArray);
result = sourceTextArray.join("\n");
}
}
return result;
}
static find(sourceText, searchText) {
let result = null;
let searchIdx = 0;
const maxSearchIdx = searchText.length - 1;
for (let sourceIdx = 0; sourceIdx < sourceText.length; sourceIdx++) {
const sourceLine = sourceText[sourceIdx].trim();
const searchLine = searchText[searchIdx].trim();
if (searchLine == sourceLine) {
if (searchIdx == maxSearchIdx) {
result = sourceIdx - searchIdx;
break;
}
searchIdx++;
} else {
searchIdx = 0;
}
}
return result;
}
};
// src/file.ts
var frontmatterTagPseudoLineNum = -1;
var SrTFile = class {
constructor(vault, metadataCache, file) {
this.vault = vault;
this.metadataCache = metadataCache;
this.file = file;
}
get path() {
return this.file.path;
}
get basename() {
return this.file.basename;
}
get tfile() {
return this.file;
}
async getFrontmatter() {
const fileCachedData = this.metadataCache.getFileCache(this.file) || {};
const frontmatter = fileCachedData.frontmatter || {};
const result = /* @__PURE__ */ new Map();
for (const [key, value] of Object.entries(frontmatter)) {
const v2 = Array.isArray(value) && value.length > 0 ? value[0] : value;
const vStr = v2 + "";
result.set(key, vStr);
}
return result;
}
getAllTagsFromCache() {
const fileCachedData = this.metadataCache.getFileCache(this.file) || {};
const result = (0, import_obsidian2.getAllTags)(fileCachedData) || [];
return result;
}
getAllTagsFromText() {
var _a;
const result = [];
const fileCachedData = this.metadataCache.getFileCache(this.file) || {};
if (((_a = fileCachedData.tags) == null ? void 0 : _a.length) > 0) {
result.push(...fileCachedData.tags);
}
result.push(...this.getFrontmatterTags(fileCachedData.frontmatter));
return result;
}
getFrontmatterTags(frontmatter) {
const result = [];
const frontmatterTags = frontmatter != null ? frontmatter["tags"] + "" : null;
if (frontmatterTags) {
const tagStrList = parseObsidianFrontmatterTag(frontmatterTags);
for (const str of tagStrList) {
const tag = {
tag: str,
position: {
start: {
line: frontmatterTagPseudoLineNum,
col: null,
offset: null
},
end: {
line: frontmatterTagPseudoLineNum,
col: null,
offset: null
}
}
};
result.push(tag);
}
}
return result;
}
getQuestionContext(cardLine) {
const fileCachedData = this.metadataCache.getFileCache(this.file) || {};
const headings = fileCachedData.headings || [];
const stack = [];
for (const heading of headings) {
if (heading.position.start.line > cardLine) {
break;
}
while (stack.length > 0 && stack[stack.length - 1].level >= heading.level) {
stack.pop();
}
stack.push(heading);
}
const result = [];
for (const headingObj of stack) {
headingObj.heading = headingObj.heading.replace(/\[\^\d+\]/gm, "").trim();
result.push(headingObj.heading);
}
return result;
}
getTextDirection() {
let result = 0 /* Unspecified */;
const fileCache = this.metadataCache.getFileCache(this.file);
const frontMatter = fileCache == null ? void 0 : fileCache.frontmatter;
if (frontMatter && (frontMatter == null ? void 0 : frontMatter.direction)) {
const str = (frontMatter.direction + "").toLowerCase();
result = str == "rtl" ? 2 /* Rtl */ : 1 /* Ltr */;
}
return result;
}
async read() {
return await this.vault.read(this.file);
}
async write(content) {
await this.vault.modify(this.file, content);
}
};
// src/note.ts
var Note = class {
get hasChanged() {
return this.questionList.some((question) => question.hasChanged);
}
get filePath() {
return this.file.path;
}
constructor(file, questionList) {
this.file = file;
this.questionList = questionList;
questionList.forEach((question) => question.note = this);
}
appendCardsToDeck(deck) {
for (const question of this.questionList) {
for (const card of question.cards) {
deck.appendCard(question.topicPathList, card);
}
}
}
debugLogToConsole(desc = "") {
var _a;
let str = `Note: ${desc}: ${this.questionList.length} questions\r
`;
for (let i2 = 0; i2 < this.questionList.length; i2++) {
const q2 = this.questionList[i2];
str += `[${i2}]: ${q2.questionType}: ${q2.lineNo}: ${(_a = q2.topicPathList) == null ? void 0 : _a.format("|")}: ${q2.questionText.original}\r
`;
}
console.debug(str);
}
async writeNoteFile(settings) {
let fileText = await this.file.read();
for (const question of this.questionList) {
if (question.hasChanged) {
fileText = question.updateQuestionWithinNoteText(fileText, settings);
}
}
await this.file.write(fileText);
this.questionList.forEach((question) => question.hasChanged = false);
}
};
// src/card.ts
var Card = class extends RepetitionItem {
constructor(init) {
super();
Object.assign(this, init);
}
get cardListType() {
return this.isNew ? 0 /* NewCard */ : 1 /* DueCard */;
}
formatSchedule() {
let result = "";
if (this.hasSchedule) result = this.scheduleInfo.formatCardScheduleForHtmlComment();
else result = "New";
return result;
}
};
// src/parser.ts
var import_clozecraft = __toESM(require_dist());
// src/question.ts
var QuestionText = class _QuestionText {
constructor(original, topicPathWithWs, actualQuestion, textDirection, blockId) {
this.original = original;
this.topicPathWithWs = topicPathWithWs;
this.actualQuestion = actualQuestion;
this.textDirection = textDirection;
this.obsidianBlockId = blockId;
this.textHash = cyrb53(this.formatTopicAndQuestion());
}
endsWithCodeBlock() {
return this.actualQuestion.endsWith("```");
}
static create(original, textDirection, settings) {
const [topicPathWithWs, actualQuestion, blockId] = this.splitText(original, settings);
return new _QuestionText(original, topicPathWithWs, actualQuestion, textDirection, blockId);
}
static splitText(original, settings) {
const originalWithoutSR = DataStore.getInstance().questionRemoveScheduleInfo(original);
let actualQuestion = originalWithoutSR.trimEnd();
let topicPathWithWs = null;
let blockId = null;
const topicPath = TopicPath.getTopicPathFromCardText(originalWithoutSR);
if (topicPath == null ? void 0 : topicPath.hasPath) {
const [preTopicPathWs, cardText2] = stringTrimStart(originalWithoutSR);
const cardText3 = cardText2.replaceAll(OBSIDIAN_TAG_AT_STARTOFLINE_REGEX, "");
let postTopicPathWs = null;
[postTopicPathWs, actualQuestion] = stringTrimStart(cardText3);
if (!settings.convertFoldersToDecks) {
topicPathWithWs = new TopicPathWithWs(topicPath, preTopicPathWs, postTopicPathWs);
}
}
[actualQuestion, blockId] = this.extractObsidianBlockId(actualQuestion);
return [topicPathWithWs, actualQuestion, blockId];
}
static extractObsidianBlockId(text) {
let question = text;
let blockId = null;
const match2 = text.match(OBSIDIAN_BLOCK_ID_ENDOFLINE_REGEX);
if (match2) {
blockId = match2[0].trim();
const newLength = question.length - blockId.length;
question = question.substring(0, newLength).trimEnd();
}
return [question, blockId];
}
formatTopicAndQuestion() {
let result = "";
if (this.topicPathWithWs) {
result += this.topicPathWithWs.formatWithWs();
}
result += this.actualQuestion;
return result;
}
};
var Question = class _Question {
get questionType() {
return this.parsedQuestionInfo.cardType;
}
get lineNo() {
return this.parsedQuestionInfo.firstLineNum;
}
constructor(init) {
Object.assign(this, init);
}
getHtmlCommentSeparator(settings) {
const sep2 = this.isCardCommentsOnSameLine(settings) ? " " : "\n";
return sep2;
}
isCardCommentsOnSameLine(settings) {
let result = settings.cardCommentOnSameLine;
if (this.questionText.endsWithCodeBlock()) {
result = false;
}
return result;
}
setCardList(cards) {
this.cards = cards;
this.cards.forEach((card) => card.question = this);
}
formatForNote(settings) {
let result = this.questionText.formatTopicAndQuestion();
const blockId = this.questionText.obsidianBlockId;
const hasSchedule = this.cards.some((card) => card.hasSchedule);
if (hasSchedule) {
result = result.trimEnd();
const scheduleHtml = DataStoreAlgorithm.getInstance().questionFormatScheduleAsHtmlComment(this);
if (blockId) {
if (this.isCardCommentsOnSameLine(settings))
result += ` ${scheduleHtml} ${blockId}`;
else result += ` ${blockId}
${scheduleHtml}`;
} else {
result += this.getHtmlCommentSeparator(settings) + scheduleHtml;
}
} else {
if (blockId) result += ` ${blockId}`;
}
return result;
}
updateQuestionWithinNoteText(noteText, settings) {
const originalText = this.questionText.original;
const replacementText = this.formatForNote(settings);
let newText = MultiLineTextFinder.findAndReplace(noteText, originalText, replacementText);
if (newText) {
this.questionText = QuestionText.create(
replacementText,
this.questionText.textDirection,
settings
);
} else {
console.error(
`updateQuestionText: Text not found: ${originalText.substring(
0,
100
)} in note: ${noteText.substring(0, 100)}`
);
newText = noteText;
}
return newText;
}
async writeQuestion(settings) {
const fileText = await this.note.file.read();
const newText = this.updateQuestionWithinNoteText(fileText, settings);
await this.note.file.write(newText);
this.hasChanged = false;
}
formatTopicPathList() {
return this.topicPathList.format("|");
}
static Create(settings, parsedQuestionInfo, noteTopicPathList, textDirection, context) {
const hasEditLaterTag = parsedQuestionInfo.text.includes(settings.editLaterTag);
const questionText = QuestionText.create(
parsedQuestionInfo.text,
textDirection,
settings
);
let topicPathList = noteTopicPathList;
if (questionText.topicPathWithWs) {
topicPathList = new TopicPathList([questionText.topicPathWithWs.topicPath]);
}
const result = new _Question({
parsedQuestionInfo,
topicPathList,
questionText,
hasEditLaterTag,
questionContext: context,
cards: null,
hasChanged: false
});
return result;
}
};
// src/parser.ts
var debugParser = false;
function setDebugParser(value) {
debugParser = value;
}
var ParsedQuestionInfo = class {
constructor(cardType, text, firstLineNum, lastLineNum) {
this.cardType = cardType;
this.text = text;
this.firstLineNum = firstLineNum;
this.lastLineNum = lastLineNum;
}
isQuestionLineNum(lineNum) {
return lineNum >= this.firstLineNum && lineNum <= this.lastLineNum;
}
};
function markerInsideCodeBlock(text, marker, markerIndex) {
let goingBack = markerIndex - 1, goingForward = markerIndex + marker.length;
let backTicksBefore = 0, backTicksAfter = 0;
while (goingBack >= 0) {
if (text[goingBack] === "`") backTicksBefore++;
goingBack--;
}
while (goingForward < text.length) {
if (text[goingForward] === "`") backTicksAfter++;
goingForward++;
}
return backTicksBefore % 2 === 1 && backTicksAfter % 2 === 1;
}
function hasInlineMarker(text, marker) {
if (marker.length == 0) return false;
const markerIdx = text.indexOf(marker);
if (markerIdx === -1) return false;
return !markerInsideCodeBlock(text, marker, markerIdx);
}
function parse(text, options) {
if (debugParser) {
console.log("Text to parse:\n<<<" + text + ">>>");
}
const inlineSeparators = [
{ separator: options.singleLineCardSeparator, type: 0 /* SingleLineBasic */ },
{ separator: options.singleLineReversedCardSeparator, type: 1 /* SingleLineReversed */ }
];
inlineSeparators.sort((a2, b2) => b2.separator.length - a2.separator.length);
const cards = [];
let cardText = "";
let cardType = null;
let firstLineNo = 0, lastLineNo = 0;
const clozecrafter = new import_clozecraft.ClozeCrafter(options.clozePatterns);
const lines = text.replaceAll("\r\n", "\n").split("\n");
for (let i2 = 0; i2 < lines.length; i2++) {
const currentLine = lines[i2], currentTrimmed = lines[i2].trim();
if (currentLine.startsWith("")) i2++;
i2++;
continue;
}
const isEmptyLine = currentTrimmed.length == 0;
const hasMultilineCardEndMarker = options.multilineCardEndMarker && currentTrimmed == options.multilineCardEndMarker;
if (
// We've probably reached the end of a card
isEmptyLine && !options.multilineCardEndMarker || // Empty line & we're not picking up any card
isEmptyLine && cardType == null || // We've reached the end of a multi line card &
// we're using custom end markers
hasMultilineCardEndMarker
) {
if (cardType) {
lastLineNo = i2 - 1;
cards.push(
new ParsedQuestionInfo(cardType, cardText.trimEnd(), firstLineNo, lastLineNo)
);
cardType = null;
}
cardText = "";
firstLineNo = i2 + 1;
continue;
}
if (cardText.length > 0) {
cardText += "\n";
}
cardText += currentLine.trimEnd();
for (const { separator, type } of inlineSeparators) {
if (hasInlineMarker(currentLine, separator)) {
cardType = type;
break;
}
}
if (cardType == 0 /* SingleLineBasic */ || cardType == 1 /* SingleLineReversed */) {
cardText = currentLine;
firstLineNo = i2;
if (i2 + 1 < lines.length && lines[i2 + 1].startsWith("/gm, "");
}
async questionWriteSchedule(question) {
await this.questionWrite(question);
}
async questionWrite(question) {
const fileText = await question.note.file.read();
const newText = question.updateQuestionWithinNoteText(fileText, this.settings);
await question.note.file.write(newText);
question.hasChanged = false;
}
};
// src/gui/flashcard-modal.tsx
var import_obsidian7 = require("obsidian");
// src/gui/deck-list-view.tsx
var import_vhtml = __toESM(require_vhtml());
var DeckListView = class {
constructor(plugin, settings, reviewSequencer, contentEl, startReviewOfDeck) {
this.plugin = plugin;
this.settings = settings;
this.reviewSequencer = reviewSequencer;
this.modalContentEl = contentEl;
this.startReviewOfDeck = startReviewOfDeck;
this.init();
}
/**
* Initializes all static elements in the DeckListView
*/
init() {
this.view = this.modalContentEl.createDiv();
this.view.addClasses(["sr-deck-list", "sr-is-hidden"]);
this.header = this.view.createDiv();
this.header.addClass("sr-header");
this.title = this.header.createDiv();
this.title.addClass("sr-title");
this.title.setText(t("DECKS"));
this.stats = this.header.createDiv();
this.stats.addClass("sr-header-stats-container");
this._createHeaderStats();
this.content = this.view.createDiv();
this.content.addClass("sr-content");
}
/**
* Shows the DeckListView & rerenders dynamic elements
*/
show() {
this.mode = 0 /* DecksList */;
this._createHeaderStats();
this.content.empty();
for (const deck of this.reviewSequencer.originalDeckTree.subdecks) {
this._createTree(deck, this.content);
}
if (this.view.hasClass("sr-is-hidden")) {
this.view.removeClass("sr-is-hidden");
}
}
/**
* Hides the DeckListView
*/
hide() {
if (!this.view.hasClass("sr-is-hidden")) {
this.view.addClass("sr-is-hidden");
}
}
/**
* Closes the DeckListView
*/
close() {
this.hide();
}
// -> Header
_createHeaderStats() {
const statistics = this.reviewSequencer.getDeckStats(TopicPath.emptyPath);
this.stats.empty();
this._createHeaderStatsContainer(t("DUE_CARDS"), statistics.dueCount, "sr-bg-green");
this._createHeaderStatsContainer(t("NEW_CARDS"), statistics.newCount, "sr-bg-blue");
this._createHeaderStatsContainer(t("TOTAL_CARDS"), statistics.totalCount, "sr-bg-red");
}
_createHeaderStatsContainer(statsLable, statsNumber, statsClass) {
const statsContainer = this.stats.createDiv();
statsContainer.ariaLabel = statsLable;
statsContainer.addClasses([
"tag-pane-tag-count",
"tree-item-flair",
"sr-header-stats-count",
statsClass
]);
const lable = statsContainer.createDiv();
lable.setText(statsLable + ":");
const number = statsContainer.createDiv();
number.setText(statsNumber.toString());
}
// -> Tree content
_createTree(deck, container) {
const deckTree = container.createDiv("tree-item sr-tree-item-container");
const deckTreeSelf = deckTree.createDiv(
"tree-item-self tag-pane-tag is-clickable sr-tree-item-row"
);
const shouldBeInitiallyExpanded = this.settings.initiallyExpandAllSubdecksInTree;
let collapsed = !shouldBeInitiallyExpanded;
let collapseIconEl = null;
if (deck.subdecks.length > 0) {
collapseIconEl = deckTreeSelf.createDiv("tree-item-icon collapse-icon");
collapseIconEl.innerHTML = COLLAPSE_ICON;
collapseIconEl.childNodes[0].style.transform = collapsed ? "rotate(-90deg)" : "";
}
const deckTreeInner = deckTreeSelf.createDiv("tree-item-inner");
const deckTreeInnerText = deckTreeInner.createDiv("tag-pane-tag-text");
deckTreeInnerText.innerHTML += /* @__PURE__ */ (0, import_vhtml.default)("span", { class: "tag-pane-tag-self" }, deck.deckName);
const deckTreeOuter = deckTreeSelf.createDiv();
deckTreeOuter.addClasses(["tree-item-flair-outer", "sr-tree-stats-container"]);
const deckStats = this.reviewSequencer.getDeckStats(deck.getTopicPath());
this._createStats(deckStats, deckTreeOuter);
const deckTreeChildren = deckTree.createDiv("tree-item-children");
deckTreeChildren.style.display = collapsed ? "none" : "block";
if (deck.subdecks.length > 0) {
collapseIconEl.addEventListener("click", (e2) => {
if (collapsed) {
collapseIconEl.childNodes[0].style.transform = "";
deckTreeChildren.style.display = "block";
} else {
collapseIconEl.childNodes[0].style.transform = "rotate(-90deg)";
deckTreeChildren.style.display = "none";
}
e2.stopPropagation();
collapsed = !collapsed;
});
}
deckTreeSelf.addEventListener("click", () => {
this.startReviewOfDeck(deck);
});
for (const subdeck of deck.subdecks) {
this._createTree(subdeck, deckTreeChildren);
}
}
_createStats(statistics, statsWrapper) {
statsWrapper.empty();
this._createStatsContainer(
t("DUE_CARDS"),
statistics.dueCount,
"sr-bg-green",
statsWrapper
);
this._createStatsContainer(t("NEW_CARDS"), statistics.newCount, "sr-bg-blue", statsWrapper);
this._createStatsContainer(
t("TOTAL_CARDS"),
statistics.totalCount,
"sr-bg-red",
statsWrapper
);
}
_createStatsContainer(statsLable, statsNumber, statsClass, statsWrapper) {
const statsContainer = statsWrapper.createDiv();
statsContainer.ariaLabel = statsLable;
statsContainer.addClasses([
"tag-pane-tag-count",
"tree-item-flair",
"sr-tree-stats-count",
statsClass
]);
statsContainer.setText(statsNumber.toString());
}
};
// src/gui/edit-modal.tsx
var import_obsidian4 = require("obsidian");
var FlashcardEditModal = class _FlashcardEditModal extends import_obsidian4.Modal {
constructor(app, existingText, textDirection) {
super(app);
this.didSaveChanges = false;
// -> Functions & helpers
this.saveClickCallback = (_2) => this.save();
this.cancelClickCallback = (_2) => this.cancel();
this.saveOnEnterCallback = (evt) => {
if ((evt.ctrlKey || evt.metaKey) && evt.key === "Enter") {
evt.preventDefault();
this.save();
}
};
this.modalText = existingText;
this.changedText = existingText;
this.textDirection = textDirection;
this.waitForClose = new Promise((resolve2, reject) => {
this.resolvePromise = resolve2;
this.rejectPromise = reject;
});
this.modalEl.addClasses(["sr-modal", "sr-edit-modal"]);
this.init();
this.open();
}
static Prompt(app, placeholder, textDirection) {
const newPromptModal = new _FlashcardEditModal(app, placeholder, textDirection);
return newPromptModal.waitForClose;
}
/**
* Initializes all components of the EditModal
*/
init() {
var _a;
this.contentEl.empty();
this.contentEl.addClass("sr-edit-view");
this.title = this.contentEl.createDiv();
this.title.setText(t("EDIT_CARD"));
this.title.addClass("sr-title");
this.textArea = this.contentEl.createEl("textarea");
this.textArea.addClass("sr-input");
this.textArea.setText((_a = this.modalText) != null ? _a : "");
this.textArea.addEventListener("keydown", this.saveOnEnterCallback);
if (this.textDirection == 2 /* Rtl */) {
this.textArea.setAttribute("dir", "rtl");
}
this._createResponse(this.contentEl);
}
/**
* Opens the EditModal
*/
onOpen() {
super.onOpen();
this.textArea.focus();
}
/**
* Closes the EditModal
*/
onClose() {
super.onClose();
this.resolveInput();
this.removeInputListener();
}
save() {
this.didSaveChanges = true;
this.changedText = this.textArea.value;
this.close();
}
cancel() {
this.close();
}
resolveInput() {
if (!this.didSaveChanges) this.rejectPromise(t("NO_INPUT"));
else this.resolvePromise(this.changedText);
}
removeInputListener() {
this.textArea.removeEventListener("keydown", this.saveOnEnterCallback);
}
// -> Response section
_createResponseButton(container, text, colorClass, callback2) {
const button = container.createEl("button");
button.addClasses(["sr-response-button", colorClass]);
button.setText(text);
button.addEventListener("click", callback2);
}
_createResponse(mainContentContainer) {
const response = mainContentContainer.createDiv();
response.addClass("sr-response");
this._createResponseButton(response, t("CANCEL"), "sr-bg-red", this.cancelClickCallback);
this._createResponseButton(response, "", "sr-spacer", () => {
});
this._createResponseButton(response, t("SAVE"), "sr-bg-green", this.saveClickCallback);
}
};
// src/gui/flashcard-review-view.tsx
var import_moment4 = __toESM(require_moment());
var import_obsidian6 = require("obsidian");
// src/utils/renderers.ts
var import_obsidian5 = require("obsidian");
var RenderMarkdownWrapper = class {
constructor(app, plugin, notePath) {
this.app = app;
this.notePath = notePath;
this.plugin = plugin;
}
// slightly modified version of the renderMarkdown function in
// https://github.com/mgmeyers/obsidian-kanban/blob/main/src/KanbanView.tsx
async renderMarkdownWrapper(markdownString, containerEl, textDirection, recursiveDepth = 0) {
if (recursiveDepth > 4) return;
let el;
if (textDirection == 2 /* Rtl */) {
el = containerEl.createDiv();
el.setAttribute("dir", "rtl");
} else el = containerEl;
import_obsidian5.MarkdownRenderer.render(this.app, markdownString, el, this.notePath, this.plugin);
el.findAll(".internal-embed").forEach((el2) => {
const link2 = this.parseLink(el2.getAttribute("src"));
if (!link2.target) {
el2.innerText = link2.text;
} else if (link2.target instanceof import_obsidian5.TFile) {
if (link2.target.extension !== "md") {
this.embedMediaFile(el2, link2.target);
} else {
}
}
});
}
parseLink(src) {
const linkComponentsRegex = /^(?[^#^]+)?(?:#(?!\^)(?.+)|#\^(?.+)|#)?$/;
const matched = typeof src === "string" && src.match(linkComponentsRegex);
const file = matched.groups.file || this.notePath;
const target = this.plugin.app.metadataCache.getFirstLinkpathDest(file, this.notePath);
return {
text: matched[0],
file: matched.groups.file,
heading: matched.groups.heading,
blockId: matched.groups.blockId,
target
};
}
embedMediaFile(el, target) {
el.innerText = "";
if (IMAGE_FORMATS.includes(target.extension)) {
el.createEl(
"img",
{
attr: {
src: this.plugin.app.vault.getResourcePath(target)
}
},
(img) => {
if (el.hasAttribute("width"))
img.setAttribute("width", el.getAttribute("width"));
else img.setAttribute("width", "100%");
if (el.hasAttribute("alt")) img.setAttribute("alt", el.getAttribute("alt"));
el.addEventListener(
"click",
(ev) => ev.target.style.minWidth = ev.target.style.minWidth === "100%" ? null : "100%"
);
}
);
el.addClasses(["image-embed", "is-loaded"]);
} else if (AUDIO_FORMATS.includes(target.extension) || VIDEO_FORMATS.includes(target.extension)) {
el.createEl(
AUDIO_FORMATS.includes(target.extension) ? "audio" : "video",
{
attr: {
controls: "",
src: this.plugin.app.vault.getResourcePath(target)
}
},
(audio) => {
if (el.hasAttribute("alt")) audio.setAttribute("alt", el.getAttribute("alt"));
}
);
el.addClasses(["media-embed", "is-loaded"]);
} else {
el.innerText = target.path;
}
}
};
// src/gui/flashcard-review-view.tsx
var FlashcardReviewView = class {
constructor(app, plugin, settings, reviewSequencer, reviewMode, contentEl, modalEl, backClickHandler, editClickHandler) {
this._keydownHandler = (e2) => {
if (document.activeElement.nodeName === "TEXTAREA" || this.mode === 3 /* Closed */) {
return;
}
const consumeKeyEvent = () => {
e2.preventDefault();
e2.stopPropagation();
};
switch (e2.code) {
case "KeyS":
this._skipCurrentCard();
consumeKeyEvent();
break;
case "Space":
if (this.mode === 1 /* Front */) {
this._showAnswer();
consumeKeyEvent();
} else if (this.mode === 2 /* Back */) {
this._processReview(1 /* Good */);
consumeKeyEvent();
}
break;
case "Enter":
case "NumpadEnter":
if (this.mode !== 1 /* Front */) {
break;
}
this._showAnswer();
consumeKeyEvent();
break;
case "Numpad1":
case "Digit1":
if (this.mode !== 2 /* Back */) {
break;
}
this._processReview(2 /* Hard */);
consumeKeyEvent();
break;
case "Numpad2":
case "Digit2":
if (this.mode !== 2 /* Back */) {
break;
}
this._processReview(1 /* Good */);
consumeKeyEvent();
break;
case "Numpad3":
case "Digit3":
if (this.mode !== 2 /* Back */) {
break;
}
this._processReview(0 /* Easy */);
consumeKeyEvent();
break;
case "Numpad0":
case "Digit0":
if (this.mode !== 2 /* Back */) {
break;
}
this._processReview(3 /* Reset */);
consumeKeyEvent();
break;
default:
break;
}
};
this.app = app;
this.plugin = plugin;
this.settings = settings;
this.reviewSequencer = reviewSequencer;
this.reviewMode = reviewMode;
this.backClickHandler = backClickHandler;
this.editClickHandler = editClickHandler;
this.modalContentEl = contentEl;
this.modalEl = modalEl;
this.chosenDeck = null;
this.init();
}
/**
* Initializes all static elements in the FlashcardView
*/
init() {
this._createBackButton();
this.view = this.modalContentEl.createDiv();
this.view.addClasses(["sr-flashcard", "sr-is-hidden"]);
this.header = this.view.createDiv();
this.header.addClass("sr-header");
this.titleWrapper = this.header.createDiv();
this.titleWrapper.addClass("sr-title-wrapper");
this.title = this.titleWrapper.createDiv();
this.title.addClass("sr-title");
this.subTitle = this.titleWrapper.createDiv();
this.subTitle.addClasses(["sr-sub-title", "sr-is-hidden"]);
this.controls = this.header.createDiv();
this.controls.addClass("sr-controls");
this._createCardControls();
if (this.settings.showContextInCards) {
this.context = this.view.createDiv();
this.context.addClass("sr-context");
}
this.content = this.view.createDiv();
this.content.addClass("sr-content");
this.response = this.view.createDiv();
this.response.addClass("sr-response");
this._createResponseButtons();
}
/**
* Shows the FlashcardView if it is hidden
*/
async show(chosenDeck) {
if (!this.view.hasClass("sr-is-hidden")) {
return;
}
this.chosenDeck = chosenDeck;
await this._drawContent();
this.view.removeClass("sr-is-hidden");
this.backButton.removeClass("sr-is-hidden");
document.addEventListener("keydown", this._keydownHandler);
}
/**
* Refreshes all dynamic elements
*/
async refresh() {
await this._drawContent();
}
/**
* Hides the FlashcardView if it is visible
*/
hide() {
if (this.view.hasClass("sr-is-hidden")) {
return;
}
document.removeEventListener("keydown", this._keydownHandler);
this.view.addClass("sr-is-hidden");
this.backButton.addClass("sr-is-hidden");
}
/**
* Closes the FlashcardView
*/
close() {
this.hide();
document.removeEventListener("keydown", this._keydownHandler);
}
// #region -> Functions & helpers
async _drawContent() {
this.mode = 1 /* Front */;
const currentDeck = this.reviewSequencer.currentDeck;
this._setTitle(this.chosenDeck);
this._setSubTitle(this.chosenDeck, currentDeck);
this.resetButton.disabled = true;
if (this.settings.showContextInCards) {
this.context.setText(
this._formatQuestionContextText(this._currentQuestion.questionContext)
);
}
this.content.empty();
const wrapper = new RenderMarkdownWrapper(
this.app,
this.plugin,
this._currentNote.filePath
);
await wrapper.renderMarkdownWrapper(
this._currentCard.front.trimStart(),
this.content,
this._currentQuestion.questionText.textDirection
);
this.content.scrollTop = 0;
this._resetResponseButtons();
}
_displayCurrentCardInfoNotice() {
var _a;
const schedule = this._currentCard.scheduleInfo;
const currentEaseStr = t("CURRENT_EASE_HELP_TEXT") + ((_a = schedule == null ? void 0 : schedule.latestEase) != null ? _a : t("NEW"));
const currentIntervalStr = t("CURRENT_INTERVAL_HELP_TEXT") + textInterval(schedule == null ? void 0 : schedule.interval, false);
const generatedFromStr = t("CARD_GENERATED_FROM", {
notePath: this._currentQuestion.note.filePath
});
new import_obsidian6.Notice(currentEaseStr + "\n" + currentIntervalStr + "\n" + generatedFromStr);
}
get _currentCard() {
return this.reviewSequencer.currentCard;
}
get _currentQuestion() {
return this.reviewSequencer.currentQuestion;
}
get _currentNote() {
return this.reviewSequencer.currentNote;
}
_showAnswer() {
const timeNow = (0, import_moment4.now)();
if (this.lastPressed && timeNow - this.lastPressed < this.plugin.data.settings.reviewButtonDelay) {
return;
}
this.lastPressed = timeNow;
this.mode = 2 /* Back */;
this.resetButton.disabled = false;
if (this._currentQuestion.questionType !== 4 /* Cloze */) {
const hr = document.createElement("hr");
hr.addClass("sr-card-divide");
this.content.appendChild(hr);
} else {
this.content.empty();
}
const wrapper = new RenderMarkdownWrapper(
this.app,
this.plugin,
this._currentNote.filePath
);
wrapper.renderMarkdownWrapper(
this._currentCard.back,
this.content,
this._currentQuestion.questionText.textDirection
);
this.answerButton.addClass("sr-is-hidden");
this.hardButton.removeClass("sr-is-hidden");
this.easyButton.removeClass("sr-is-hidden");
if (this.reviewMode === 0 /* Cram */) {
this.response.addClass("is-cram");
this.hardButton.setText(`${this.settings.flashcardHardText}`);
this.easyButton.setText(`${this.settings.flashcardEasyText}`);
} else {
this.goodButton.removeClass("sr-is-hidden");
this._setupEaseButton(
this.hardButton,
this.settings.flashcardHardText,
2 /* Hard */
);
this._setupEaseButton(
this.goodButton,
this.settings.flashcardGoodText,
1 /* Good */
);
this._setupEaseButton(
this.easyButton,
this.settings.flashcardEasyText,
0 /* Easy */
);
}
}
async _processReview(response) {
const timeNow = (0, import_moment4.now)();
if (this.lastPressed && timeNow - this.lastPressed < this.plugin.data.settings.reviewButtonDelay) {
return;
}
this.lastPressed = timeNow;
await this.reviewSequencer.processReview(response);
await this._handleSkipCard();
}
async _skipCurrentCard() {
this.reviewSequencer.skipCurrentCard();
await this._handleSkipCard();
}
async _handleSkipCard() {
if (this._currentCard != null) await this.refresh();
else this.backClickHandler();
}
_formatQuestionContextText(questionContext) {
const separator = " > ";
let result = this._currentNote.file.basename;
questionContext.forEach((context) => {
if (context.startsWith("[[") && context.endsWith("]]")) {
context = context.replace("[[", "").replace("]]", "");
if (context.contains("|")) {
context = context.split("|")[1];
}
}
result += separator + context;
});
return result;
}
// -> Header
_createBackButton() {
this.backButton = this.modalEl.createDiv();
this.backButton.addClasses(["sr-back-button", "sr-is-hidden"]);
(0, import_obsidian6.setIcon)(this.backButton, "arrow-left");
this.backButton.setAttribute("aria-label", t("BACK"));
this.backButton.addEventListener("click", () => {
this.backClickHandler();
});
}
_setTitle(deck) {
let text = deck.deckName;
const deckStats = this.reviewSequencer.getDeckStats(deck.getTopicPath());
const cardsInQueue = deckStats.dueCount + deckStats.newCount;
text += `: ${cardsInQueue}`;
this.title.setText(text);
}
_setSubTitle(chosenDeck, currentDeck) {
if (chosenDeck.subdecks.length === 0) {
if (!this.subTitle.hasClass("sr-is-hidden")) {
this.subTitle.addClass("sr-is-hidden");
}
return;
}
if (this.subTitle.hasClass("sr-is-hidden")) {
this.subTitle.removeClass("sr-is-hidden");
}
let text = `${currentDeck.deckName}`;
const isRandomMode = this.settings.flashcardCardOrder === "EveryCardRandomDeckAndCard";
if (!isRandomMode) {
const subDecksWithCardsInQueue = chosenDeck.subdecks.filter((subDeck) => {
const deckStats = this.reviewSequencer.getDeckStats(subDeck.getTopicPath());
return deckStats.dueCount + deckStats.newCount > 0;
});
text = `${t("DECKS")}: ${subDecksWithCardsInQueue.length} | ${text}`;
text += `: ${currentDeck.getCardCount(2 /* All */, false)}`;
}
this.subTitle.setText(text);
}
// -> Controls
_createCardControls() {
this._createEditButton();
this._createResetButton();
this._createCardInfoButton();
this._createSkipButton();
}
_createEditButton() {
this.editButton = this.controls.createEl("button");
this.editButton.addClasses(["sr-button", "sr-edit-button"]);
(0, import_obsidian6.setIcon)(this.editButton, "edit");
this.editButton.setAttribute("aria-label", t("EDIT_CARD"));
this.editButton.addEventListener("click", async () => {
this.editClickHandler();
});
}
_createResetButton() {
this.resetButton = this.controls.createEl("button");
this.resetButton.addClasses(["sr-button", "sr-reset-button"]);
(0, import_obsidian6.setIcon)(this.resetButton, "refresh-cw");
this.resetButton.setAttribute("aria-label", t("RESET_CARD_PROGRESS"));
this.resetButton.addEventListener("click", () => {
this._processReview(3 /* Reset */);
});
}
_createCardInfoButton() {
this.infoButton = this.controls.createEl("button");
this.infoButton.addClasses(["sr-button", "sr-info-button"]);
(0, import_obsidian6.setIcon)(this.infoButton, "info");
this.infoButton.setAttribute("aria-label", "View Card Info");
this.infoButton.addEventListener("click", async () => {
this._displayCurrentCardInfoNotice();
});
}
_createSkipButton() {
this.skipButton = this.controls.createEl("button");
this.skipButton.addClasses(["sr-button", "sr-skip-button"]);
(0, import_obsidian6.setIcon)(this.skipButton, "chevrons-right");
this.skipButton.setAttribute("aria-label", t("SKIP"));
this.skipButton.addEventListener("click", () => {
this._skipCurrentCard();
});
}
// -> Response
_createResponseButtons() {
this._createShowAnswerButton();
this._createHardButton();
this._createGoodButton();
this._createEasyButton();
}
_resetResponseButtons() {
this.answerButton.removeClass("sr-is-hidden");
this.hardButton.addClass("sr-is-hidden");
this.goodButton.addClass("sr-is-hidden");
this.easyButton.addClass("sr-is-hidden");
}
_createShowAnswerButton() {
this.answerButton = this.response.createEl("button");
this.answerButton.addClasses(["sr-response-button", "sr-show-answer-button", "sr-bg-blue"]);
this.answerButton.setText(t("SHOW_ANSWER"));
this.answerButton.addEventListener("click", () => {
this._showAnswer();
});
}
_createHardButton() {
this.hardButton = this.response.createEl("button");
this.hardButton.addClasses([
"sr-response-button",
"sr-hard-button",
"sr-bg-red",
"sr-is-hidden"
]);
this.hardButton.setText(this.settings.flashcardHardText);
this.hardButton.addEventListener("click", () => {
this._processReview(2 /* Hard */);
});
}
_createGoodButton() {
this.goodButton = this.response.createEl("button");
this.goodButton.addClasses([
"sr-response-button",
"sr-good-button",
"sr-bg-blue",
"sr-is-hidden"
]);
this.goodButton.setText(this.settings.flashcardGoodText);
this.goodButton.addEventListener("click", () => {
this._processReview(1 /* Good */);
});
}
_createEasyButton() {
this.easyButton = this.response.createEl("button");
this.easyButton.addClasses([
"sr-response-button",
"sr-hard-button",
"sr-bg-green",
"sr-is-hidden"
]);
this.easyButton.setText(this.settings.flashcardEasyText);
this.easyButton.addEventListener("click", () => {
this._processReview(0 /* Easy */);
});
}
_setupEaseButton(button, buttonName, reviewResponse) {
const schedule = this.reviewSequencer.determineCardSchedule(
reviewResponse,
this._currentCard
);
const interval = schedule.interval;
if (this.settings.showIntervalInReviewButtons) {
if (import_obsidian6.Platform.isMobile) {
button.setText(textInterval(interval, true));
} else {
button.setText(`${buttonName} - ${textInterval(interval, false)}`);
}
} else {
button.setText(buttonName);
}
}
};
// src/gui/flashcard-modal.tsx
var FlashcardModal = class extends import_obsidian7.Modal {
constructor(app, plugin, settings, reviewSequencer, reviewMode) {
super(app);
this.plugin = plugin;
this.settings = settings;
this.reviewSequencer = reviewSequencer;
this.reviewMode = reviewMode;
this.modalEl.style.height = this.settings.flashcardHeightPercentage + "%";
this.modalEl.style.maxHeight = this.settings.flashcardHeightPercentage + "%";
this.modalEl.style.width = this.settings.flashcardWidthPercentage + "%";
this.modalEl.style.maxWidth = this.settings.flashcardWidthPercentage + "%";
this.modalEl.setAttribute("id", "sr-modal");
this.contentEl.addClass("sr-modal-content");
this.deckView = new DeckListView(
this.plugin,
this.settings,
this.reviewSequencer,
this.contentEl,
this._startReviewOfDeck.bind(this)
);
this.flashcardView = new FlashcardReviewView(
this.app,
this.plugin,
this.settings,
this.reviewSequencer,
this.reviewMode,
this.contentEl,
this.modalEl,
this._showDecksList.bind(this),
this._doEditQuestionText.bind(this)
);
}
onOpen() {
this._showDecksList();
}
onClose() {
this.mode = 3 /* Closed */;
this.deckView.close();
this.flashcardView.close();
}
_showDecksList() {
this._hideFlashcard();
this.deckView.show();
}
_hideDecksList() {
this.deckView.hide();
}
_showFlashcard(deck) {
this._hideDecksList();
this.flashcardView.show(deck);
}
_hideFlashcard() {
this.flashcardView.hide();
}
_startReviewOfDeck(deck) {
this.reviewSequencer.setCurrentDeck(deck.getTopicPath());
if (this.reviewSequencer.hasCurrentCard) {
this._showFlashcard(deck);
} else {
this._showDecksList();
}
}
async _doEditQuestionText() {
const currentQ = this.reviewSequencer.currentQuestion;
const textPrompt = currentQ.questionText.actualQuestion;
const editModal = FlashcardEditModal.Prompt(
this.app,
textPrompt,
currentQ.questionText.textDirection
);
editModal.then(async (modifiedCardText) => {
this.reviewSequencer.updateCurrentQuestionText(modifiedCardText);
}).catch((reason) => console.log(reason));
}
};
// src/gui/review-queue-list-view.tsx
var import_obsidian8 = require("obsidian");
var REVIEW_QUEUE_VIEW_TYPE = "review-queue-list-view";
var ReviewQueueListView = class extends import_obsidian8.ItemView {
get noteReviewQueue() {
return this.nextNoteReviewHandler.noteReviewQueue;
}
constructor(leaf, nextNoteReviewHandler, settings) {
super(leaf);
this.nextNoteReviewHandler = nextNoteReviewHandler;
this.settings = settings;
if (this.settings.enableNoteReviewPaneOnStartup) {
this.registerEvent(this.app.workspace.on("file-open", () => this.redraw()));
this.registerEvent(this.app.vault.on("rename", () => this.redraw()));
}
}
getViewType() {
return REVIEW_QUEUE_VIEW_TYPE;
}
getDisplayText() {
return t("NOTES_REVIEW_QUEUE");
}
getIcon() {
return "SpacedRepIcon";
}
onHeaderMenu(menu) {
menu.addItem((item) => {
item.setTitle(t("CLOSE")).setIcon("cross").onClick(() => {
this.app.workspace.detachLeavesOfType(REVIEW_QUEUE_VIEW_TYPE);
});
});
}
redraw() {
if (!this.noteReviewQueue.reviewDecks) return;
const activeFile = this.app.workspace.getActiveFile();
const rootEl = createDiv("tree-item nav-folder mod-root");
const childrenEl = rootEl.createDiv("tree-item-children nav-folder-children");
for (const [deckKey, deck] of this.noteReviewQueue.reviewDecks) {
const deckCollapsed = !deck.activeFolders.has(deck.deckName);
const deckFolderEl = this.createRightPaneFolder(
childrenEl,
deckKey,
deckCollapsed,
false,
deck
).getElementsByClassName("tree-item-children nav-folder-children")[0];
if (deck.newNotes.length > 0) {
const newNotesFolderEl = this.createRightPaneFolder(
deckFolderEl,
t("NEW"),
!deck.activeFolders.has(t("NEW")),
deckCollapsed,
deck
);
for (const newFile of deck.newNotes) {
const fileIsOpen = activeFile && newFile.path === activeFile.path;
if (fileIsOpen) {
deck.activeFolders.add(deck.deckName);
deck.activeFolders.add(t("NEW"));
this.changeFolderFolding(newNotesFolderEl);
this.changeFolderFolding(deckFolderEl);
}
this.createRightPaneFile(
newNotesFolderEl,
newFile.tfile,
fileIsOpen,
!deck.activeFolders.has(t("NEW")),
deck
);
}
}
if (deck.scheduledNotes.length > 0) {
const now2 = Date.now();
let currUnix = -1;
let schedFolderEl = null, folderTitle = "";
const maxDaysToRender = this.settings.maxNDaysNotesReviewQueue;
for (const sNote of deck.scheduledNotes) {
if (sNote.dueUnix != currUnix) {
const nDays = Math.ceil((sNote.dueUnix - now2) / TICKS_PER_DAY);
if (nDays > maxDaysToRender) {
break;
}
if (nDays === -1) {
folderTitle = t("YESTERDAY");
} else if (nDays === 0) {
folderTitle = t("TODAY");
} else if (nDays === 1) {
folderTitle = t("TOMORROW");
} else {
folderTitle = new Date(sNote.dueUnix).toDateString();
}
schedFolderEl = this.createRightPaneFolder(
deckFolderEl,
folderTitle,
!deck.activeFolders.has(folderTitle),
deckCollapsed,
deck
);
currUnix = sNote.dueUnix;
}
const fileIsOpen = activeFile && sNote.note.path === activeFile.path;
if (fileIsOpen) {
deck.activeFolders.add(deck.deckName);
deck.activeFolders.add(folderTitle);
this.changeFolderFolding(schedFolderEl);
this.changeFolderFolding(deckFolderEl);
}
this.createRightPaneFile(
schedFolderEl,
sNote.note.tfile,
fileIsOpen,
!deck.activeFolders.has(folderTitle),
deck
);
}
}
}
const contentEl = this.containerEl.children[1];
contentEl.empty();
contentEl.appendChild(rootEl);
}
createRightPaneFolder(parentEl, folderTitle, collapsed, hidden, deck) {
const folderEl = parentEl.createDiv("tree-item nav-folder");
const folderTitleEl = folderEl.createDiv("tree-item-self nav-folder-title");
const childrenEl = folderEl.createDiv(
"tree-item-children nav-folder-children"
);
const collapseIconEl = folderTitleEl.createDiv(
"tree-item-icon collapse-icon nav-folder-collapse-indicator"
);
collapseIconEl.innerHTML = COLLAPSE_ICON;
this.changeFolderFolding(folderEl, collapsed);
folderTitleEl.createDiv("tree-item-inner nav-folder-title-content").setText(folderTitle);
if (hidden) {
folderEl.style.display = "none";
}
folderTitleEl.onClickEvent(() => {
this.changeFolderFolding(folderEl, !folderEl.hasClass("is-collapsed"));
childrenEl.style.display = !folderEl.hasClass("is-collapsed") ? "block" : "none";
if (!folderEl.hasClass("is-collapsed")) {
deck.activeFolders.delete(folderTitle);
} else {
deck.activeFolders.add(folderTitle);
}
});
return folderEl;
}
createRightPaneFile(folderEl, file, fileElActive, hidden, deck) {
const childrenEl = folderEl.getElementsByClassName(
"tree-item-children nav-folder-children"
)[0];
const navFileEl = childrenEl.createDiv("nav-file");
if (hidden) {
childrenEl.style.display = "none";
}
const navFileTitle = navFileEl.createDiv("tree-item-self nav-file-title");
if (fileElActive) {
navFileTitle.addClass("is-active");
}
navFileTitle.createDiv("tree-item-inner nav-file-title-content").setText(file.basename);
navFileTitle.addEventListener(
"click",
async (event) => {
event.preventDefault();
await this.nextNoteReviewHandler.openNote(deck.deckName, file);
return false;
},
false
);
navFileTitle.addEventListener(
"contextmenu",
(event) => {
event.preventDefault();
const fileMenu = new import_obsidian8.Menu();
this.app.workspace.trigger("file-menu", fileMenu, file, "my-context-menu", null);
fileMenu.showAtPosition({
x: event.pageX,
y: event.pageY
});
return false;
},
false
);
}
changeFolderFolding(folderEl, collapsed = false) {
if (collapsed) {
folderEl.addClass("is-collapsed");
const collapseIconEl = folderEl.find("div.nav-folder-collapse-indicator");
collapseIconEl.addClass("is-collapsed");
} else {
folderEl.removeClass("is-collapsed");
const collapseIconEl = folderEl.find("div.nav-folder-collapse-indicator");
collapseIconEl.removeClass("is-collapsed");
}
}
};
// src/gui/settings.tsx
var import_obsidian10 = require("obsidian");
// node_modules/.pnpm/@kurkle+color@0.3.2/node_modules/@kurkle/color/dist/color.esm.js
function round(v2) {
return v2 + 0.5 | 0;
}
var lim = (v2, l2, h6) => Math.max(Math.min(v2, h6), l2);
function p2b(v2) {
return lim(round(v2 * 2.55), 0, 255);
}
function n2b(v2) {
return lim(round(v2 * 255), 0, 255);
}
function b2n(v2) {
return lim(round(v2 / 2.55) / 100, 0, 1);
}
function n2p(v2) {
return lim(round(v2 * 100), 0, 100);
}
var map$1 = { 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, A: 10, B: 11, C: 12, D: 13, E: 14, F: 15, a: 10, b: 11, c: 12, d: 13, e: 14, f: 15 };
var hex = [..."0123456789ABCDEF"];
var h1 = (b2) => hex[b2 & 15];
var h2 = (b2) => hex[(b2 & 240) >> 4] + hex[b2 & 15];
var eq = (b2) => (b2 & 240) >> 4 === (b2 & 15);
var isShort = (v2) => eq(v2.r) && eq(v2.g) && eq(v2.b) && eq(v2.a);
function hexParse(str) {
var len = str.length;
var ret;
if (str[0] === "#") {
if (len === 4 || len === 5) {
ret = {
r: 255 & map$1[str[1]] * 17,
g: 255 & map$1[str[2]] * 17,
b: 255 & map$1[str[3]] * 17,
a: len === 5 ? map$1[str[4]] * 17 : 255
};
} else if (len === 7 || len === 9) {
ret = {
r: map$1[str[1]] << 4 | map$1[str[2]],
g: map$1[str[3]] << 4 | map$1[str[4]],
b: map$1[str[5]] << 4 | map$1[str[6]],
a: len === 9 ? map$1[str[7]] << 4 | map$1[str[8]] : 255
};
}
}
return ret;
}
var alpha = (a2, f2) => a2 < 255 ? f2(a2) : "";
function hexString(v2) {
var f2 = isShort(v2) ? h1 : h2;
return v2 ? "#" + f2(v2.r) + f2(v2.g) + f2(v2.b) + alpha(v2.a, f2) : void 0;
}
var HUE_RE = /^(hsla?|hwb|hsv)\(\s*([-+.e\d]+)(?:deg)?[\s,]+([-+.e\d]+)%[\s,]+([-+.e\d]+)%(?:[\s,]+([-+.e\d]+)(%)?)?\s*\)$/;
function hsl2rgbn(h6, s2, l2) {
const a2 = s2 * Math.min(l2, 1 - l2);
const f2 = (n2, k = (n2 + h6 / 30) % 12) => l2 - a2 * Math.max(Math.min(k - 3, 9 - k, 1), -1);
return [f2(0), f2(8), f2(4)];
}
function hsv2rgbn(h6, s2, v2) {
const f2 = (n2, k = (n2 + h6 / 60) % 6) => v2 - v2 * s2 * Math.max(Math.min(k, 4 - k, 1), 0);
return [f2(5), f2(3), f2(1)];
}
function hwb2rgbn(h6, w2, b2) {
const rgb = hsl2rgbn(h6, 1, 0.5);
let i2;
if (w2 + b2 > 1) {
i2 = 1 / (w2 + b2);
w2 *= i2;
b2 *= i2;
}
for (i2 = 0; i2 < 3; i2++) {
rgb[i2] *= 1 - w2 - b2;
rgb[i2] += w2;
}
return rgb;
}
function hueValue(r2, g2, b2, d2, max) {
if (r2 === max) {
return (g2 - b2) / d2 + (g2 < b2 ? 6 : 0);
}
if (g2 === max) {
return (b2 - r2) / d2 + 2;
}
return (r2 - g2) / d2 + 4;
}
function rgb2hsl(v2) {
const range = 255;
const r2 = v2.r / range;
const g2 = v2.g / range;
const b2 = v2.b / range;
const max = Math.max(r2, g2, b2);
const min = Math.min(r2, g2, b2);
const l2 = (max + min) / 2;
let h6, s2, d2;
if (max !== min) {
d2 = max - min;
s2 = l2 > 0.5 ? d2 / (2 - max - min) : d2 / (max + min);
h6 = hueValue(r2, g2, b2, d2, max);
h6 = h6 * 60 + 0.5;
}
return [h6 | 0, s2 || 0, l2];
}
function calln(f2, a2, b2, c2) {
return (Array.isArray(a2) ? f2(a2[0], a2[1], a2[2]) : f2(a2, b2, c2)).map(n2b);
}
function hsl2rgb(h6, s2, l2) {
return calln(hsl2rgbn, h6, s2, l2);
}
function hwb2rgb(h6, w2, b2) {
return calln(hwb2rgbn, h6, w2, b2);
}
function hsv2rgb(h6, s2, v2) {
return calln(hsv2rgbn, h6, s2, v2);
}
function hue(h6) {
return (h6 % 360 + 360) % 360;
}
function hueParse(str) {
const m2 = HUE_RE.exec(str);
let a2 = 255;
let v2;
if (!m2) {
return;
}
if (m2[5] !== v2) {
a2 = m2[6] ? p2b(+m2[5]) : n2b(+m2[5]);
}
const h6 = hue(+m2[2]);
const p1 = +m2[3] / 100;
const p2 = +m2[4] / 100;
if (m2[1] === "hwb") {
v2 = hwb2rgb(h6, p1, p2);
} else if (m2[1] === "hsv") {
v2 = hsv2rgb(h6, p1, p2);
} else {
v2 = hsl2rgb(h6, p1, p2);
}
return {
r: v2[0],
g: v2[1],
b: v2[2],
a: a2
};
}
function rotate(v2, deg) {
var h6 = rgb2hsl(v2);
h6[0] = hue(h6[0] + deg);
h6 = hsl2rgb(h6);
v2.r = h6[0];
v2.g = h6[1];
v2.b = h6[2];
}
function hslString(v2) {
if (!v2) {
return;
}
const a2 = rgb2hsl(v2);
const h6 = a2[0];
const s2 = n2p(a2[1]);
const l2 = n2p(a2[2]);
return v2.a < 255 ? `hsla(${h6}, ${s2}%, ${l2}%, ${b2n(v2.a)})` : `hsl(${h6}, ${s2}%, ${l2}%)`;
}
var map = {
x: "dark",
Z: "light",
Y: "re",
X: "blu",
W: "gr",
V: "medium",
U: "slate",
A: "ee",
T: "ol",
S: "or",
B: "ra",
C: "lateg",
D: "ights",
R: "in",
Q: "turquois",
E: "hi",
P: "ro",
O: "al",
N: "le",
M: "de",
L: "yello",
F: "en",
K: "ch",
G: "arks",
H: "ea",
I: "ightg",
J: "wh"
};
var names$1 = {
OiceXe: "f0f8ff",
antiquewEte: "faebd7",
aqua: "ffff",
aquamarRe: "7fffd4",
azuY: "f0ffff",
beige: "f5f5dc",
bisque: "ffe4c4",
black: "0",
blanKedOmond: "ffebcd",
Xe: "ff",
XeviTet: "8a2be2",
bPwn: "a52a2a",
burlywood: "deb887",
caMtXe: "5f9ea0",
KartYuse: "7fff00",
KocTate: "d2691e",
cSO: "ff7f50",
cSnflowerXe: "6495ed",
cSnsilk: "fff8dc",
crimson: "dc143c",
cyan: "ffff",
xXe: "8b",
xcyan: "8b8b",
xgTMnPd: "b8860b",
xWay: "a9a9a9",
xgYF: "6400",
xgYy: "a9a9a9",
xkhaki: "bdb76b",
xmagFta: "8b008b",
xTivegYF: "556b2f",
xSange: "ff8c00",
xScEd: "9932cc",
xYd: "8b0000",
xsOmon: "e9967a",
xsHgYF: "8fbc8f",
xUXe: "483d8b",
xUWay: "2f4f4f",
xUgYy: "2f4f4f",
xQe: "ced1",
xviTet: "9400d3",
dAppRk: "ff1493",
dApskyXe: "bfff",
dimWay: "696969",
dimgYy: "696969",
dodgerXe: "1e90ff",
fiYbrick: "b22222",
flSOwEte: "fffaf0",
foYstWAn: "228b22",
fuKsia: "ff00ff",
gaRsbSo: "dcdcdc",
ghostwEte: "f8f8ff",
gTd: "ffd700",
gTMnPd: "daa520",
Way: "808080",
gYF: "8000",
gYFLw: "adff2f",
gYy: "808080",
honeyMw: "f0fff0",
hotpRk: "ff69b4",
RdianYd: "cd5c5c",
Rdigo: "4b0082",
ivSy: "fffff0",
khaki: "f0e68c",
lavFMr: "e6e6fa",
lavFMrXsh: "fff0f5",
lawngYF: "7cfc00",
NmoncEffon: "fffacd",
ZXe: "add8e6",
ZcSO: "f08080",
Zcyan: "e0ffff",
ZgTMnPdLw: "fafad2",
ZWay: "d3d3d3",
ZgYF: "90ee90",
ZgYy: "d3d3d3",
ZpRk: "ffb6c1",
ZsOmon: "ffa07a",
ZsHgYF: "20b2aa",
ZskyXe: "87cefa",
ZUWay: "778899",
ZUgYy: "778899",
ZstAlXe: "b0c4de",
ZLw: "ffffe0",
lime: "ff00",
limegYF: "32cd32",
lRF: "faf0e6",
magFta: "ff00ff",
maPon: "800000",
VaquamarRe: "66cdaa",
VXe: "cd",
VScEd: "ba55d3",
VpurpN: "9370db",
VsHgYF: "3cb371",
VUXe: "7b68ee",
VsprRggYF: "fa9a",
VQe: "48d1cc",
VviTetYd: "c71585",
midnightXe: "191970",
mRtcYam: "f5fffa",
mistyPse: "ffe4e1",
moccasR: "ffe4b5",
navajowEte: "ffdead",
navy: "80",
Tdlace: "fdf5e6",
Tive: "808000",
TivedBb: "6b8e23",
Sange: "ffa500",
SangeYd: "ff4500",
ScEd: "da70d6",
pOegTMnPd: "eee8aa",
pOegYF: "98fb98",
pOeQe: "afeeee",
pOeviTetYd: "db7093",
papayawEp: "ffefd5",
pHKpuff: "ffdab9",
peru: "cd853f",
pRk: "ffc0cb",
plum: "dda0dd",
powMrXe: "b0e0e6",
purpN: "800080",
YbeccapurpN: "663399",
Yd: "ff0000",
Psybrown: "bc8f8f",
PyOXe: "4169e1",
saddNbPwn: "8b4513",
sOmon: "fa8072",
sandybPwn: "f4a460",
sHgYF: "2e8b57",
sHshell: "fff5ee",
siFna: "a0522d",
silver: "c0c0c0",
skyXe: "87ceeb",
UXe: "6a5acd",
UWay: "708090",
UgYy: "708090",
snow: "fffafa",
sprRggYF: "ff7f",
stAlXe: "4682b4",
tan: "d2b48c",
teO: "8080",
tEstN: "d8bfd8",
tomato: "ff6347",
Qe: "40e0d0",
viTet: "ee82ee",
JHt: "f5deb3",
wEte: "ffffff",
wEtesmoke: "f5f5f5",
Lw: "ffff00",
LwgYF: "9acd32"
};
function unpack() {
const unpacked = {};
const keys = Object.keys(names$1);
const tkeys = Object.keys(map);
let i2, j2, k, ok, nk;
for (i2 = 0; i2 < keys.length; i2++) {
ok = nk = keys[i2];
for (j2 = 0; j2 < tkeys.length; j2++) {
k = tkeys[j2];
nk = nk.replace(k, map[k]);
}
k = parseInt(names$1[ok], 16);
unpacked[nk] = [k >> 16 & 255, k >> 8 & 255, k & 255];
}
return unpacked;
}
var names;
function nameParse(str) {
if (!names) {
names = unpack();
names.transparent = [0, 0, 0, 0];
}
const a2 = names[str.toLowerCase()];
return a2 && {
r: a2[0],
g: a2[1],
b: a2[2],
a: a2.length === 4 ? a2[3] : 255
};
}
var RGB_RE = /^rgba?\(\s*([-+.\d]+)(%)?[\s,]+([-+.e\d]+)(%)?[\s,]+([-+.e\d]+)(%)?(?:[\s,/]+([-+.e\d]+)(%)?)?\s*\)$/;
function rgbParse(str) {
const m2 = RGB_RE.exec(str);
let a2 = 255;
let r2, g2, b2;
if (!m2) {
return;
}
if (m2[7] !== r2) {
const v2 = +m2[7];
a2 = m2[8] ? p2b(v2) : lim(v2 * 255, 0, 255);
}
r2 = +m2[1];
g2 = +m2[3];
b2 = +m2[5];
r2 = 255 & (m2[2] ? p2b(r2) : lim(r2, 0, 255));
g2 = 255 & (m2[4] ? p2b(g2) : lim(g2, 0, 255));
b2 = 255 & (m2[6] ? p2b(b2) : lim(b2, 0, 255));
return {
r: r2,
g: g2,
b: b2,
a: a2
};
}
function rgbString(v2) {
return v2 && (v2.a < 255 ? `rgba(${v2.r}, ${v2.g}, ${v2.b}, ${b2n(v2.a)})` : `rgb(${v2.r}, ${v2.g}, ${v2.b})`);
}
var to = (v2) => v2 <= 31308e-7 ? v2 * 12.92 : Math.pow(v2, 1 / 2.4) * 1.055 - 0.055;
var from = (v2) => v2 <= 0.04045 ? v2 / 12.92 : Math.pow((v2 + 0.055) / 1.055, 2.4);
function interpolate2(rgb1, rgb2, t3) {
const r2 = from(b2n(rgb1.r));
const g2 = from(b2n(rgb1.g));
const b2 = from(b2n(rgb1.b));
return {
r: n2b(to(r2 + t3 * (from(b2n(rgb2.r)) - r2))),
g: n2b(to(g2 + t3 * (from(b2n(rgb2.g)) - g2))),
b: n2b(to(b2 + t3 * (from(b2n(rgb2.b)) - b2))),
a: rgb1.a + t3 * (rgb2.a - rgb1.a)
};
}
function modHSL(v2, i2, ratio) {
if (v2) {
let tmp = rgb2hsl(v2);
tmp[i2] = Math.max(0, Math.min(tmp[i2] + tmp[i2] * ratio, i2 === 0 ? 360 : 1));
tmp = hsl2rgb(tmp);
v2.r = tmp[0];
v2.g = tmp[1];
v2.b = tmp[2];
}
}
function clone(v2, proto) {
return v2 ? Object.assign(proto || {}, v2) : v2;
}
function fromObject(input) {
var v2 = { r: 0, g: 0, b: 0, a: 255 };
if (Array.isArray(input)) {
if (input.length >= 3) {
v2 = { r: input[0], g: input[1], b: input[2], a: 255 };
if (input.length > 3) {
v2.a = n2b(input[3]);
}
}
} else {
v2 = clone(input, { r: 0, g: 0, b: 0, a: 1 });
v2.a = n2b(v2.a);
}
return v2;
}
function functionParse(str) {
if (str.charAt(0) === "r") {
return rgbParse(str);
}
return hueParse(str);
}
var Color = class _Color {
constructor(input) {
if (input instanceof _Color) {
return input;
}
const type = typeof input;
let v2;
if (type === "object") {
v2 = fromObject(input);
} else if (type === "string") {
v2 = hexParse(input) || nameParse(input) || functionParse(input);
}
this._rgb = v2;
this._valid = !!v2;
}
get valid() {
return this._valid;
}
get rgb() {
var v2 = clone(this._rgb);
if (v2) {
v2.a = b2n(v2.a);
}
return v2;
}
set rgb(obj) {
this._rgb = fromObject(obj);
}
rgbString() {
return this._valid ? rgbString(this._rgb) : void 0;
}
hexString() {
return this._valid ? hexString(this._rgb) : void 0;
}
hslString() {
return this._valid ? hslString(this._rgb) : void 0;
}
mix(color2, weight) {
if (color2) {
const c1 = this.rgb;
const c2 = color2.rgb;
let w2;
const p2 = weight === w2 ? 0.5 : weight;
const w3 = 2 * p2 - 1;
const a2 = c1.a - c2.a;
const w1 = ((w3 * a2 === -1 ? w3 : (w3 + a2) / (1 + w3 * a2)) + 1) / 2;
w2 = 1 - w1;
c1.r = 255 & w1 * c1.r + w2 * c2.r + 0.5;
c1.g = 255 & w1 * c1.g + w2 * c2.g + 0.5;
c1.b = 255 & w1 * c1.b + w2 * c2.b + 0.5;
c1.a = p2 * c1.a + (1 - p2) * c2.a;
this.rgb = c1;
}
return this;
}
interpolate(color2, t3) {
if (color2) {
this._rgb = interpolate2(this._rgb, color2._rgb, t3);
}
return this;
}
clone() {
return new _Color(this.rgb);
}
alpha(a2) {
this._rgb.a = n2b(a2);
return this;
}
clearer(ratio) {
const rgb = this._rgb;
rgb.a *= 1 - ratio;
return this;
}
greyscale() {
const rgb = this._rgb;
const val = round(rgb.r * 0.3 + rgb.g * 0.59 + rgb.b * 0.11);
rgb.r = rgb.g = rgb.b = val;
return this;
}
opaquer(ratio) {
const rgb = this._rgb;
rgb.a *= 1 + ratio;
return this;
}
negate() {
const v2 = this._rgb;
v2.r = 255 - v2.r;
v2.g = 255 - v2.g;
v2.b = 255 - v2.b;
return this;
}
lighten(ratio) {
modHSL(this._rgb, 2, ratio);
return this;
}
darken(ratio) {
modHSL(this._rgb, 2, -ratio);
return this;
}
saturate(ratio) {
modHSL(this._rgb, 1, ratio);
return this;
}
desaturate(ratio) {
modHSL(this._rgb, 1, -ratio);
return this;
}
rotate(deg) {
rotate(this._rgb, deg);
return this;
}
};
// node_modules/.pnpm/chart.js@4.4.4/node_modules/chart.js/dist/chunks/helpers.segment.js
function noop() {
}
var uid = /* @__PURE__ */ (() => {
let id = 0;
return () => id++;
})();
function isNullOrUndef(value) {
return value === null || typeof value === "undefined";
}
function isArray(value) {
if (Array.isArray && Array.isArray(value)) {
return true;
}
const type = Object.prototype.toString.call(value);
if (type.slice(0, 7) === "[object" && type.slice(-6) === "Array]") {
return true;
}
return false;
}
function isObject(value) {
return value !== null && Object.prototype.toString.call(value) === "[object Object]";
}
function isNumberFinite(value) {
return (typeof value === "number" || value instanceof Number) && isFinite(+value);
}
function finiteOrDefault(value, defaultValue) {
return isNumberFinite(value) ? value : defaultValue;
}
function valueOrDefault(value, defaultValue) {
return typeof value === "undefined" ? defaultValue : value;
}
var toPercentage = (value, dimension) => typeof value === "string" && value.endsWith("%") ? parseFloat(value) / 100 : +value / dimension;
var toDimension = (value, dimension) => typeof value === "string" && value.endsWith("%") ? parseFloat(value) / 100 * dimension : +value;
function callback(fn2, args, thisArg) {
if (fn2 && typeof fn2.call === "function") {
return fn2.apply(thisArg, args);
}
}
function each(loopable, fn2, thisArg, reverse) {
let i2, len, keys;
if (isArray(loopable)) {
len = loopable.length;
if (reverse) {
for (i2 = len - 1; i2 >= 0; i2--) {
fn2.call(thisArg, loopable[i2], i2);
}
} else {
for (i2 = 0; i2 < len; i2++) {
fn2.call(thisArg, loopable[i2], i2);
}
}
} else if (isObject(loopable)) {
keys = Object.keys(loopable);
len = keys.length;
for (i2 = 0; i2 < len; i2++) {
fn2.call(thisArg, loopable[keys[i2]], keys[i2]);
}
}
}
function _elementsEqual(a0, a1) {
let i2, ilen, v0, v1;
if (!a0 || !a1 || a0.length !== a1.length) {
return false;
}
for (i2 = 0, ilen = a0.length; i2 < ilen; ++i2) {
v0 = a0[i2];
v1 = a1[i2];
if (v0.datasetIndex !== v1.datasetIndex || v0.index !== v1.index) {
return false;
}
}
return true;
}
function clone2(source) {
if (isArray(source)) {
return source.map(clone2);
}
if (isObject(source)) {
const target = /* @__PURE__ */ Object.create(null);
const keys = Object.keys(source);
const klen = keys.length;
let k = 0;
for (; k < klen; ++k) {
target[keys[k]] = clone2(source[keys[k]]);
}
return target;
}
return source;
}
function isValidKey(key) {
return [
"__proto__",
"prototype",
"constructor"
].indexOf(key) === -1;
}
function _merger(key, target, source, options) {
if (!isValidKey(key)) {
return;
}
const tval = target[key];
const sval = source[key];
if (isObject(tval) && isObject(sval)) {
merge(tval, sval, options);
} else {
target[key] = clone2(sval);
}
}
function merge(target, source, options) {
const sources = isArray(source) ? source : [
source
];
const ilen = sources.length;
if (!isObject(target)) {
return target;
}
options = options || {};
const merger = options.merger || _merger;
let current;
for (let i2 = 0; i2 < ilen; ++i2) {
current = sources[i2];
if (!isObject(current)) {
continue;
}
const keys = Object.keys(current);
for (let k = 0, klen = keys.length; k < klen; ++k) {
merger(keys[k], target, current, options);
}
}
return target;
}
function mergeIf(target, source) {
return merge(target, source, {
merger: _mergerIf
});
}
function _mergerIf(key, target, source) {
if (!isValidKey(key)) {
return;
}
const tval = target[key];
const sval = source[key];
if (isObject(tval) && isObject(sval)) {
mergeIf(tval, sval);
} else if (!Object.prototype.hasOwnProperty.call(target, key)) {
target[key] = clone2(sval);
}
}
var keyResolvers = {
// Chart.helpers.core resolveObjectKey should resolve empty key to root object
"": (v2) => v2,
// default resolvers
x: (o2) => o2.x,
y: (o2) => o2.y
};
function _splitKey(key) {
const parts = key.split(".");
const keys = [];
let tmp = "";
for (const part of parts) {
tmp += part;
if (tmp.endsWith("\\")) {
tmp = tmp.slice(0, -1) + ".";
} else {
keys.push(tmp);
tmp = "";
}
}
return keys;
}
function _getKeyResolver(key) {
const keys = _splitKey(key);
return (obj) => {
for (const k of keys) {
if (k === "") {
break;
}
obj = obj && obj[k];
}
return obj;
};
}
function resolveObjectKey(obj, key) {
const resolver = keyResolvers[key] || (keyResolvers[key] = _getKeyResolver(key));
return resolver(obj);
}
function _capitalize(str) {
return str.charAt(0).toUpperCase() + str.slice(1);
}
var defined = (value) => typeof value !== "undefined";
var isFunction = (value) => typeof value === "function";
var setsEqual = (a2, b2) => {
if (a2.size !== b2.size) {
return false;
}
for (const item of a2) {
if (!b2.has(item)) {
return false;
}
}
return true;
};
function _isClickEvent(e2) {
return e2.type === "mouseup" || e2.type === "click" || e2.type === "contextmenu";
}
var PI = Math.PI;
var TAU = 2 * PI;
var PITAU = TAU + PI;
var INFINITY = Number.POSITIVE_INFINITY;
var RAD_PER_DEG = PI / 180;
var HALF_PI = PI / 2;
var QUARTER_PI = PI / 4;
var TWO_THIRDS_PI = PI * 2 / 3;
var log10 = Math.log10;
var sign = Math.sign;
function almostEquals(x2, y2, epsilon) {
return Math.abs(x2 - y2) < epsilon;
}
function niceNum(range) {
const roundedRange = Math.round(range);
range = almostEquals(range, roundedRange, range / 1e3) ? roundedRange : range;
const niceRange = Math.pow(10, Math.floor(log10(range)));
const fraction = range / niceRange;
const niceFraction = fraction <= 1 ? 1 : fraction <= 2 ? 2 : fraction <= 5 ? 5 : 10;
return niceFraction * niceRange;
}
function _factorize(value) {
const result = [];
const sqrt = Math.sqrt(value);
let i2;
for (i2 = 1; i2 < sqrt; i2++) {
if (value % i2 === 0) {
result.push(i2);
result.push(value / i2);
}
}
if (sqrt === (sqrt | 0)) {
result.push(sqrt);
}
result.sort((a2, b2) => a2 - b2).pop();
return result;
}
function isNumber(n2) {
return !isNaN(parseFloat(n2)) && isFinite(n2);
}
function almostWhole(x2, epsilon) {
const rounded = Math.round(x2);
return rounded - epsilon <= x2 && rounded + epsilon >= x2;
}
function _setMinAndMaxByKey(array, target, property) {
let i2, ilen, value;
for (i2 = 0, ilen = array.length; i2 < ilen; i2++) {
value = array[i2][property];
if (!isNaN(value)) {
target.min = Math.min(target.min, value);
target.max = Math.max(target.max, value);
}
}
}
function toRadians(degrees) {
return degrees * (PI / 180);
}
function toDegrees(radians) {
return radians * (180 / PI);
}
function _decimalPlaces(x2) {
if (!isNumberFinite(x2)) {
return;
}
let e2 = 1;
let p2 = 0;
while (Math.round(x2 * e2) / e2 !== x2) {
e2 *= 10;
p2++;
}
return p2;
}
function getAngleFromPoint(centrePoint, anglePoint) {
const distanceFromXCenter = anglePoint.x - centrePoint.x;
const distanceFromYCenter = anglePoint.y - centrePoint.y;
const radialDistanceFromCenter = Math.sqrt(distanceFromXCenter * distanceFromXCenter + distanceFromYCenter * distanceFromYCenter);
let angle = Math.atan2(distanceFromYCenter, distanceFromXCenter);
if (angle < -0.5 * PI) {
angle += TAU;
}
return {
angle,
distance: radialDistanceFromCenter
};
}
function distanceBetweenPoints(pt1, pt2) {
return Math.sqrt(Math.pow(pt2.x - pt1.x, 2) + Math.pow(pt2.y - pt1.y, 2));
}
function _normalizeAngle(a2) {
return (a2 % TAU + TAU) % TAU;
}
function _angleBetween(angle, start, end, sameAngleIsFullCircle) {
const a2 = _normalizeAngle(angle);
const s2 = _normalizeAngle(start);
const e2 = _normalizeAngle(end);
const angleToStart = _normalizeAngle(s2 - a2);
const angleToEnd = _normalizeAngle(e2 - a2);
const startToAngle = _normalizeAngle(a2 - s2);
const endToAngle = _normalizeAngle(a2 - e2);
return a2 === s2 || a2 === e2 || sameAngleIsFullCircle && s2 === e2 || angleToStart > angleToEnd && startToAngle < endToAngle;
}
function _limitValue(value, min, max) {
return Math.max(min, Math.min(max, value));
}
function _int16Range(value) {
return _limitValue(value, -32768, 32767);
}
function _isBetween(value, start, end, epsilon = 1e-6) {
return value >= Math.min(start, end) - epsilon && value <= Math.max(start, end) + epsilon;
}
function _lookup(table, value, cmp) {
cmp = cmp || ((index) => table[index] < value);
let hi = table.length - 1;
let lo = 0;
let mid;
while (hi - lo > 1) {
mid = lo + hi >> 1;
if (cmp(mid)) {
lo = mid;
} else {
hi = mid;
}
}
return {
lo,
hi
};
}
var _lookupByKey = (table, key, value, last) => _lookup(table, value, last ? (index) => {
const ti = table[index][key];
return ti < value || ti === value && table[index + 1][key] === value;
} : (index) => table[index][key] < value);
var _rlookupByKey = (table, key, value) => _lookup(table, value, (index) => table[index][key] >= value);
function _filterBetween(values, min, max) {
let start = 0;
let end = values.length;
while (start < end && values[start] < min) {
start++;
}
while (end > start && values[end - 1] > max) {
end--;
}
return start > 0 || end < values.length ? values.slice(start, end) : values;
}
var arrayEvents = [
"push",
"pop",
"shift",
"splice",
"unshift"
];
function listenArrayEvents(array, listener) {
if (array._chartjs) {
array._chartjs.listeners.push(listener);
return;
}
Object.defineProperty(array, "_chartjs", {
configurable: true,
enumerable: false,
value: {
listeners: [
listener
]
}
});
arrayEvents.forEach((key) => {
const method = "_onData" + _capitalize(key);
const base = array[key];
Object.defineProperty(array, key, {
configurable: true,
enumerable: false,
value(...args) {
const res = base.apply(this, args);
array._chartjs.listeners.forEach((object) => {
if (typeof object[method] === "function") {
object[method](...args);
}
});
return res;
}
});
});
}
function unlistenArrayEvents(array, listener) {
const stub = array._chartjs;
if (!stub) {
return;
}
const listeners = stub.listeners;
const index = listeners.indexOf(listener);
if (index !== -1) {
listeners.splice(index, 1);
}
if (listeners.length > 0) {
return;
}
arrayEvents.forEach((key) => {
delete array[key];
});
delete array._chartjs;
}
function _arrayUnique(items) {
const set2 = new Set(items);
if (set2.size === items.length) {
return items;
}
return Array.from(set2);
}
var requestAnimFrame = function() {
if (typeof window === "undefined") {
return function(callback2) {
return callback2();
};
}
return window.requestAnimationFrame;
}();
function throttled(fn2, thisArg) {
let argsToUse = [];
let ticking = false;
return function(...args) {
argsToUse = args;
if (!ticking) {
ticking = true;
requestAnimFrame.call(window, () => {
ticking = false;
fn2.apply(thisArg, argsToUse);
});
}
};
}
function debounce(fn2, delay) {
let timeout;
return function(...args) {
if (delay) {
clearTimeout(timeout);
timeout = setTimeout(fn2, delay, args);
} else {
fn2.apply(this, args);
}
return delay;
};
}
var _toLeftRightCenter = (align) => align === "start" ? "left" : align === "end" ? "right" : "center";
var _alignStartEnd = (align, start, end) => align === "start" ? start : align === "end" ? end : (start + end) / 2;
var _textX = (align, left, right, rtl) => {
const check = rtl ? "left" : "right";
return align === check ? right : align === "center" ? (left + right) / 2 : left;
};
var atEdge = (t3) => t3 === 0 || t3 === 1;
var elasticIn = (t3, s2, p2) => -(Math.pow(2, 10 * (t3 -= 1)) * Math.sin((t3 - s2) * TAU / p2));
var elasticOut = (t3, s2, p2) => Math.pow(2, -10 * t3) * Math.sin((t3 - s2) * TAU / p2) + 1;
var effects = {
linear: (t3) => t3,
easeInQuad: (t3) => t3 * t3,
easeOutQuad: (t3) => -t3 * (t3 - 2),
easeInOutQuad: (t3) => (t3 /= 0.5) < 1 ? 0.5 * t3 * t3 : -0.5 * (--t3 * (t3 - 2) - 1),
easeInCubic: (t3) => t3 * t3 * t3,
easeOutCubic: (t3) => (t3 -= 1) * t3 * t3 + 1,
easeInOutCubic: (t3) => (t3 /= 0.5) < 1 ? 0.5 * t3 * t3 * t3 : 0.5 * ((t3 -= 2) * t3 * t3 + 2),
easeInQuart: (t3) => t3 * t3 * t3 * t3,
easeOutQuart: (t3) => -((t3 -= 1) * t3 * t3 * t3 - 1),
easeInOutQuart: (t3) => (t3 /= 0.5) < 1 ? 0.5 * t3 * t3 * t3 * t3 : -0.5 * ((t3 -= 2) * t3 * t3 * t3 - 2),
easeInQuint: (t3) => t3 * t3 * t3 * t3 * t3,
easeOutQuint: (t3) => (t3 -= 1) * t3 * t3 * t3 * t3 + 1,
easeInOutQuint: (t3) => (t3 /= 0.5) < 1 ? 0.5 * t3 * t3 * t3 * t3 * t3 : 0.5 * ((t3 -= 2) * t3 * t3 * t3 * t3 + 2),
easeInSine: (t3) => -Math.cos(t3 * HALF_PI) + 1,
easeOutSine: (t3) => Math.sin(t3 * HALF_PI),
easeInOutSine: (t3) => -0.5 * (Math.cos(PI * t3) - 1),
easeInExpo: (t3) => t3 === 0 ? 0 : Math.pow(2, 10 * (t3 - 1)),
easeOutExpo: (t3) => t3 === 1 ? 1 : -Math.pow(2, -10 * t3) + 1,
easeInOutExpo: (t3) => atEdge(t3) ? t3 : t3 < 0.5 ? 0.5 * Math.pow(2, 10 * (t3 * 2 - 1)) : 0.5 * (-Math.pow(2, -10 * (t3 * 2 - 1)) + 2),
easeInCirc: (t3) => t3 >= 1 ? t3 : -(Math.sqrt(1 - t3 * t3) - 1),
easeOutCirc: (t3) => Math.sqrt(1 - (t3 -= 1) * t3),
easeInOutCirc: (t3) => (t3 /= 0.5) < 1 ? -0.5 * (Math.sqrt(1 - t3 * t3) - 1) : 0.5 * (Math.sqrt(1 - (t3 -= 2) * t3) + 1),
easeInElastic: (t3) => atEdge(t3) ? t3 : elasticIn(t3, 0.075, 0.3),
easeOutElastic: (t3) => atEdge(t3) ? t3 : elasticOut(t3, 0.075, 0.3),
easeInOutElastic(t3) {
const s2 = 0.1125;
const p2 = 0.45;
return atEdge(t3) ? t3 : t3 < 0.5 ? 0.5 * elasticIn(t3 * 2, s2, p2) : 0.5 + 0.5 * elasticOut(t3 * 2 - 1, s2, p2);
},
easeInBack(t3) {
const s2 = 1.70158;
return t3 * t3 * ((s2 + 1) * t3 - s2);
},
easeOutBack(t3) {
const s2 = 1.70158;
return (t3 -= 1) * t3 * ((s2 + 1) * t3 + s2) + 1;
},
easeInOutBack(t3) {
let s2 = 1.70158;
if ((t3 /= 0.5) < 1) {
return 0.5 * (t3 * t3 * (((s2 *= 1.525) + 1) * t3 - s2));
}
return 0.5 * ((t3 -= 2) * t3 * (((s2 *= 1.525) + 1) * t3 + s2) + 2);
},
easeInBounce: (t3) => 1 - effects.easeOutBounce(1 - t3),
easeOutBounce(t3) {
const m2 = 7.5625;
const d2 = 2.75;
if (t3 < 1 / d2) {
return m2 * t3 * t3;
}
if (t3 < 2 / d2) {
return m2 * (t3 -= 1.5 / d2) * t3 + 0.75;
}
if (t3 < 2.5 / d2) {
return m2 * (t3 -= 2.25 / d2) * t3 + 0.9375;
}
return m2 * (t3 -= 2.625 / d2) * t3 + 0.984375;
},
easeInOutBounce: (t3) => t3 < 0.5 ? effects.easeInBounce(t3 * 2) * 0.5 : effects.easeOutBounce(t3 * 2 - 1) * 0.5 + 0.5
};
function isPatternOrGradient(value) {
if (value && typeof value === "object") {
const type = value.toString();
return type === "[object CanvasPattern]" || type === "[object CanvasGradient]";
}
return false;
}
function color(value) {
return isPatternOrGradient(value) ? value : new Color(value);
}
function getHoverColor(value) {
return isPatternOrGradient(value) ? value : new Color(value).saturate(0.5).darken(0.1).hexString();
}
var numbers = [
"x",
"y",
"borderWidth",
"radius",
"tension"
];
var colors = [
"color",
"borderColor",
"backgroundColor"
];
function applyAnimationsDefaults(defaults3) {
defaults3.set("animation", {
delay: void 0,
duration: 1e3,
easing: "easeOutQuart",
fn: void 0,
from: void 0,
loop: void 0,
to: void 0,
type: void 0
});
defaults3.describe("animation", {
_fallback: false,
_indexable: false,
_scriptable: (name) => name !== "onProgress" && name !== "onComplete" && name !== "fn"
});
defaults3.set("animations", {
colors: {
type: "color",
properties: colors
},
numbers: {
type: "number",
properties: numbers
}
});
defaults3.describe("animations", {
_fallback: "animation"
});
defaults3.set("transitions", {
active: {
animation: {
duration: 400
}
},
resize: {
animation: {
duration: 0
}
},
show: {
animations: {
colors: {
from: "transparent"
},
visible: {
type: "boolean",
duration: 0
}
}
},
hide: {
animations: {
colors: {
to: "transparent"
},
visible: {
type: "boolean",
easing: "linear",
fn: (v2) => v2 | 0
}
}
}
});
}
function applyLayoutsDefaults(defaults3) {
defaults3.set("layout", {
autoPadding: true,
padding: {
top: 0,
right: 0,
bottom: 0,
left: 0
}
});
}
var intlCache = /* @__PURE__ */ new Map();
function getNumberFormat(locale2, options) {
options = options || {};
const cacheKey = locale2 + JSON.stringify(options);
let formatter = intlCache.get(cacheKey);
if (!formatter) {
formatter = new Intl.NumberFormat(locale2, options);
intlCache.set(cacheKey, formatter);
}
return formatter;
}
function formatNumber(num, locale2, options) {
return getNumberFormat(locale2, options).format(num);
}
var formatters = {
values(value) {
return isArray(value) ? value : "" + value;
},
numeric(tickValue, index, ticks) {
if (tickValue === 0) {
return "0";
}
const locale2 = this.chart.options.locale;
let notation;
let delta = tickValue;
if (ticks.length > 1) {
const maxTick = Math.max(Math.abs(ticks[0].value), Math.abs(ticks[ticks.length - 1].value));
if (maxTick < 1e-4 || maxTick > 1e15) {
notation = "scientific";
}
delta = calculateDelta(tickValue, ticks);
}
const logDelta = log10(Math.abs(delta));
const numDecimal = isNaN(logDelta) ? 1 : Math.max(Math.min(-1 * Math.floor(logDelta), 20), 0);
const options = {
notation,
minimumFractionDigits: numDecimal,
maximumFractionDigits: numDecimal
};
Object.assign(options, this.options.ticks.format);
return formatNumber(tickValue, locale2, options);
},
logarithmic(tickValue, index, ticks) {
if (tickValue === 0) {
return "0";
}
const remain = ticks[index].significand || tickValue / Math.pow(10, Math.floor(log10(tickValue)));
if ([
1,
2,
3,
5,
10,
15
].includes(remain) || index > 0.8 * ticks.length) {
return formatters.numeric.call(this, tickValue, index, ticks);
}
return "";
}
};
function calculateDelta(tickValue, ticks) {
let delta = ticks.length > 3 ? ticks[2].value - ticks[1].value : ticks[1].value - ticks[0].value;
if (Math.abs(delta) >= 1 && tickValue !== Math.floor(tickValue)) {
delta = tickValue - Math.floor(tickValue);
}
return delta;
}
var Ticks = {
formatters
};
function applyScaleDefaults(defaults3) {
defaults3.set("scale", {
display: true,
offset: false,
reverse: false,
beginAtZero: false,
bounds: "ticks",
clip: true,
grace: 0,
grid: {
display: true,
lineWidth: 1,
drawOnChartArea: true,
drawTicks: true,
tickLength: 8,
tickWidth: (_ctx, options) => options.lineWidth,
tickColor: (_ctx, options) => options.color,
offset: false
},
border: {
display: true,
dash: [],
dashOffset: 0,
width: 1
},
title: {
display: false,
text: "",
padding: {
top: 4,
bottom: 4
}
},
ticks: {
minRotation: 0,
maxRotation: 50,
mirror: false,
textStrokeWidth: 0,
textStrokeColor: "",
padding: 3,
display: true,
autoSkip: true,
autoSkipPadding: 3,
labelOffset: 0,
callback: Ticks.formatters.values,
minor: {},
major: {},
align: "center",
crossAlign: "near",
showLabelBackdrop: false,
backdropColor: "rgba(255, 255, 255, 0.75)",
backdropPadding: 2
}
});
defaults3.route("scale.ticks", "color", "", "color");
defaults3.route("scale.grid", "color", "", "borderColor");
defaults3.route("scale.border", "color", "", "borderColor");
defaults3.route("scale.title", "color", "", "color");
defaults3.describe("scale", {
_fallback: false,
_scriptable: (name) => !name.startsWith("before") && !name.startsWith("after") && name !== "callback" && name !== "parser",
_indexable: (name) => name !== "borderDash" && name !== "tickBorderDash" && name !== "dash"
});
defaults3.describe("scales", {
_fallback: "scale"
});
defaults3.describe("scale.ticks", {
_scriptable: (name) => name !== "backdropPadding" && name !== "callback",
_indexable: (name) => name !== "backdropPadding"
});
}
var overrides = /* @__PURE__ */ Object.create(null);
var descriptors = /* @__PURE__ */ Object.create(null);
function getScope$1(node, key) {
if (!key) {
return node;
}
const keys = key.split(".");
for (let i2 = 0, n2 = keys.length; i2 < n2; ++i2) {
const k = keys[i2];
node = node[k] || (node[k] = /* @__PURE__ */ Object.create(null));
}
return node;
}
function set(root, scope, values) {
if (typeof scope === "string") {
return merge(getScope$1(root, scope), values);
}
return merge(getScope$1(root, ""), scope);
}
var Defaults = class {
constructor(_descriptors2, _appliers) {
this.animation = void 0;
this.backgroundColor = "rgba(0,0,0,0.1)";
this.borderColor = "rgba(0,0,0,0.1)";
this.color = "#666";
this.datasets = {};
this.devicePixelRatio = (context) => context.chart.platform.getDevicePixelRatio();
this.elements = {};
this.events = [
"mousemove",
"mouseout",
"click",
"touchstart",
"touchmove"
];
this.font = {
family: "'Helvetica Neue', 'Helvetica', 'Arial', sans-serif",
size: 12,
style: "normal",
lineHeight: 1.2,
weight: null
};
this.hover = {};
this.hoverBackgroundColor = (ctx, options) => getHoverColor(options.backgroundColor);
this.hoverBorderColor = (ctx, options) => getHoverColor(options.borderColor);
this.hoverColor = (ctx, options) => getHoverColor(options.color);
this.indexAxis = "x";
this.interaction = {
mode: "nearest",
intersect: true,
includeInvisible: false
};
this.maintainAspectRatio = true;
this.onHover = null;
this.onClick = null;
this.parsing = true;
this.plugins = {};
this.responsive = true;
this.scale = void 0;
this.scales = {};
this.showLine = true;
this.drawActiveElementsOnTop = true;
this.describe(_descriptors2);
this.apply(_appliers);
}
set(scope, values) {
return set(this, scope, values);
}
get(scope) {
return getScope$1(this, scope);
}
describe(scope, values) {
return set(descriptors, scope, values);
}
override(scope, values) {
return set(overrides, scope, values);
}
route(scope, name, targetScope, targetName) {
const scopeObject = getScope$1(this, scope);
const targetScopeObject = getScope$1(this, targetScope);
const privateName = "_" + name;
Object.defineProperties(scopeObject, {
[privateName]: {
value: scopeObject[name],
writable: true
},
[name]: {
enumerable: true,
get() {
const local = this[privateName];
const target = targetScopeObject[targetName];
if (isObject(local)) {
return Object.assign({}, target, local);
}
return valueOrDefault(local, target);
},
set(value) {
this[privateName] = value;
}
}
});
}
apply(appliers) {
appliers.forEach((apply) => apply(this));
}
};
var defaults2 = /* @__PURE__ */ new Defaults({
_scriptable: (name) => !name.startsWith("on"),
_indexable: (name) => name !== "events",
hover: {
_fallback: "interaction"
},
interaction: {
_scriptable: false,
_indexable: false
}
}, [
applyAnimationsDefaults,
applyLayoutsDefaults,
applyScaleDefaults
]);
function toFontString(font) {
if (!font || isNullOrUndef(font.size) || isNullOrUndef(font.family)) {
return null;
}
return (font.style ? font.style + " " : "") + (font.weight ? font.weight + " " : "") + font.size + "px " + font.family;
}
function _measureText(ctx, data, gc, longest, string) {
let textWidth = data[string];
if (!textWidth) {
textWidth = data[string] = ctx.measureText(string).width;
gc.push(string);
}
if (textWidth > longest) {
longest = textWidth;
}
return longest;
}
function _longestText(ctx, font, arrayOfThings, cache) {
cache = cache || {};
let data = cache.data = cache.data || {};
let gc = cache.garbageCollect = cache.garbageCollect || [];
if (cache.font !== font) {
data = cache.data = {};
gc = cache.garbageCollect = [];
cache.font = font;
}
ctx.save();
ctx.font = font;
let longest = 0;
const ilen = arrayOfThings.length;
let i2, j2, jlen, thing, nestedThing;
for (i2 = 0; i2 < ilen; i2++) {
thing = arrayOfThings[i2];
if (thing !== void 0 && thing !== null && !isArray(thing)) {
longest = _measureText(ctx, data, gc, longest, thing);
} else if (isArray(thing)) {
for (j2 = 0, jlen = thing.length; j2 < jlen; j2++) {
nestedThing = thing[j2];
if (nestedThing !== void 0 && nestedThing !== null && !isArray(nestedThing)) {
longest = _measureText(ctx, data, gc, longest, nestedThing);
}
}
}
}
ctx.restore();
const gcLen = gc.length / 2;
if (gcLen > arrayOfThings.length) {
for (i2 = 0; i2 < gcLen; i2++) {
delete data[gc[i2]];
}
gc.splice(0, gcLen);
}
return longest;
}
function _alignPixel(chart, pixel, width) {
const devicePixelRatio = chart.currentDevicePixelRatio;
const halfWidth = width !== 0 ? Math.max(width / 2, 0.5) : 0;
return Math.round((pixel - halfWidth) * devicePixelRatio) / devicePixelRatio + halfWidth;
}
function clearCanvas(canvas, ctx) {
if (!ctx && !canvas) {
return;
}
ctx = ctx || canvas.getContext("2d");
ctx.save();
ctx.resetTransform();
ctx.clearRect(0, 0, canvas.width, canvas.height);
ctx.restore();
}
function drawPoint(ctx, options, x2, y2) {
drawPointLegend(ctx, options, x2, y2, null);
}
function drawPointLegend(ctx, options, x2, y2, w2) {
let type, xOffset, yOffset, size, cornerRadius, width, xOffsetW, yOffsetW;
const style = options.pointStyle;
const rotation = options.rotation;
const radius = options.radius;
let rad = (rotation || 0) * RAD_PER_DEG;
if (style && typeof style === "object") {
type = style.toString();
if (type === "[object HTMLImageElement]" || type === "[object HTMLCanvasElement]") {
ctx.save();
ctx.translate(x2, y2);
ctx.rotate(rad);
ctx.drawImage(style, -style.width / 2, -style.height / 2, style.width, style.height);
ctx.restore();
return;
}
}
if (isNaN(radius) || radius <= 0) {
return;
}
ctx.beginPath();
switch (style) {
// Default includes circle
default:
if (w2) {
ctx.ellipse(x2, y2, w2 / 2, radius, 0, 0, TAU);
} else {
ctx.arc(x2, y2, radius, 0, TAU);
}
ctx.closePath();
break;
case "triangle":
width = w2 ? w2 / 2 : radius;
ctx.moveTo(x2 + Math.sin(rad) * width, y2 - Math.cos(rad) * radius);
rad += TWO_THIRDS_PI;
ctx.lineTo(x2 + Math.sin(rad) * width, y2 - Math.cos(rad) * radius);
rad += TWO_THIRDS_PI;
ctx.lineTo(x2 + Math.sin(rad) * width, y2 - Math.cos(rad) * radius);
ctx.closePath();
break;
case "rectRounded":
cornerRadius = radius * 0.516;
size = radius - cornerRadius;
xOffset = Math.cos(rad + QUARTER_PI) * size;
xOffsetW = Math.cos(rad + QUARTER_PI) * (w2 ? w2 / 2 - cornerRadius : size);
yOffset = Math.sin(rad + QUARTER_PI) * size;
yOffsetW = Math.sin(rad + QUARTER_PI) * (w2 ? w2 / 2 - cornerRadius : size);
ctx.arc(x2 - xOffsetW, y2 - yOffset, cornerRadius, rad - PI, rad - HALF_PI);
ctx.arc(x2 + yOffsetW, y2 - xOffset, cornerRadius, rad - HALF_PI, rad);
ctx.arc(x2 + xOffsetW, y2 + yOffset, cornerRadius, rad, rad + HALF_PI);
ctx.arc(x2 - yOffsetW, y2 + xOffset, cornerRadius, rad + HALF_PI, rad + PI);
ctx.closePath();
break;
case "rect":
if (!rotation) {
size = Math.SQRT1_2 * radius;
width = w2 ? w2 / 2 : size;
ctx.rect(x2 - width, y2 - size, 2 * width, 2 * size);
break;
}
rad += QUARTER_PI;
/* falls through */
case "rectRot":
xOffsetW = Math.cos(rad) * (w2 ? w2 / 2 : radius);
xOffset = Math.cos(rad) * radius;
yOffset = Math.sin(rad) * radius;
yOffsetW = Math.sin(rad) * (w2 ? w2 / 2 : radius);
ctx.moveTo(x2 - xOffsetW, y2 - yOffset);
ctx.lineTo(x2 + yOffsetW, y2 - xOffset);
ctx.lineTo(x2 + xOffsetW, y2 + yOffset);
ctx.lineTo(x2 - yOffsetW, y2 + xOffset);
ctx.closePath();
break;
case "crossRot":
rad += QUARTER_PI;
/* falls through */
case "cross":
xOffsetW = Math.cos(rad) * (w2 ? w2 / 2 : radius);
xOffset = Math.cos(rad) * radius;
yOffset = Math.sin(rad) * radius;
yOffsetW = Math.sin(rad) * (w2 ? w2 / 2 : radius);
ctx.moveTo(x2 - xOffsetW, y2 - yOffset);
ctx.lineTo(x2 + xOffsetW, y2 + yOffset);
ctx.moveTo(x2 + yOffsetW, y2 - xOffset);
ctx.lineTo(x2 - yOffsetW, y2 + xOffset);
break;
case "star":
xOffsetW = Math.cos(rad) * (w2 ? w2 / 2 : radius);
xOffset = Math.cos(rad) * radius;
yOffset = Math.sin(rad) * radius;
yOffsetW = Math.sin(rad) * (w2 ? w2 / 2 : radius);
ctx.moveTo(x2 - xOffsetW, y2 - yOffset);
ctx.lineTo(x2 + xOffsetW, y2 + yOffset);
ctx.moveTo(x2 + yOffsetW, y2 - xOffset);
ctx.lineTo(x2 - yOffsetW, y2 + xOffset);
rad += QUARTER_PI;
xOffsetW = Math.cos(rad) * (w2 ? w2 / 2 : radius);
xOffset = Math.cos(rad) * radius;
yOffset = Math.sin(rad) * radius;
yOffsetW = Math.sin(rad) * (w2 ? w2 / 2 : radius);
ctx.moveTo(x2 - xOffsetW, y2 - yOffset);
ctx.lineTo(x2 + xOffsetW, y2 + yOffset);
ctx.moveTo(x2 + yOffsetW, y2 - xOffset);
ctx.lineTo(x2 - yOffsetW, y2 + xOffset);
break;
case "line":
xOffset = w2 ? w2 / 2 : Math.cos(rad) * radius;
yOffset = Math.sin(rad) * radius;
ctx.moveTo(x2 - xOffset, y2 - yOffset);
ctx.lineTo(x2 + xOffset, y2 + yOffset);
break;
case "dash":
ctx.moveTo(x2, y2);
ctx.lineTo(x2 + Math.cos(rad) * (w2 ? w2 / 2 : radius), y2 + Math.sin(rad) * radius);
break;
case false:
ctx.closePath();
break;
}
ctx.fill();
if (options.borderWidth > 0) {
ctx.stroke();
}
}
function _isPointInArea(point, area, margin) {
margin = margin || 0.5;
return !area || point && point.x > area.left - margin && point.x < area.right + margin && point.y > area.top - margin && point.y < area.bottom + margin;
}
function clipArea(ctx, area) {
ctx.save();
ctx.beginPath();
ctx.rect(area.left, area.top, area.right - area.left, area.bottom - area.top);
ctx.clip();
}
function unclipArea(ctx) {
ctx.restore();
}
function setRenderOpts(ctx, opts) {
if (opts.translation) {
ctx.translate(opts.translation[0], opts.translation[1]);
}
if (!isNullOrUndef(opts.rotation)) {
ctx.rotate(opts.rotation);
}
if (opts.color) {
ctx.fillStyle = opts.color;
}
if (opts.textAlign) {
ctx.textAlign = opts.textAlign;
}
if (opts.textBaseline) {
ctx.textBaseline = opts.textBaseline;
}
}
function decorateText(ctx, x2, y2, line, opts) {
if (opts.strikethrough || opts.underline) {
const metrics = ctx.measureText(line);
const left = x2 - metrics.actualBoundingBoxLeft;
const right = x2 + metrics.actualBoundingBoxRight;
const top = y2 - metrics.actualBoundingBoxAscent;
const bottom = y2 + metrics.actualBoundingBoxDescent;
const yDecoration = opts.strikethrough ? (top + bottom) / 2 : bottom;
ctx.strokeStyle = ctx.fillStyle;
ctx.beginPath();
ctx.lineWidth = opts.decorationWidth || 2;
ctx.moveTo(left, yDecoration);
ctx.lineTo(right, yDecoration);
ctx.stroke();
}
}
function drawBackdrop(ctx, opts) {
const oldColor = ctx.fillStyle;
ctx.fillStyle = opts.color;
ctx.fillRect(opts.left, opts.top, opts.width, opts.height);
ctx.fillStyle = oldColor;
}
function renderText(ctx, text, x2, y2, font, opts = {}) {
const lines = isArray(text) ? text : [
text
];
const stroke = opts.strokeWidth > 0 && opts.strokeColor !== "";
let i2, line;
ctx.save();
ctx.font = font.string;
setRenderOpts(ctx, opts);
for (i2 = 0; i2 < lines.length; ++i2) {
line = lines[i2];
if (opts.backdrop) {
drawBackdrop(ctx, opts.backdrop);
}
if (stroke) {
if (opts.strokeColor) {
ctx.strokeStyle = opts.strokeColor;
}
if (!isNullOrUndef(opts.strokeWidth)) {
ctx.lineWidth = opts.strokeWidth;
}
ctx.strokeText(line, x2, y2, opts.maxWidth);
}
ctx.fillText(line, x2, y2, opts.maxWidth);
decorateText(ctx, x2, y2, line, opts);
y2 += Number(font.lineHeight);
}
ctx.restore();
}
function addRoundedRectPath(ctx, rect) {
const { x: x2, y: y2, w: w2, h: h6, radius } = rect;
ctx.arc(x2 + radius.topLeft, y2 + radius.topLeft, radius.topLeft, 1.5 * PI, PI, true);
ctx.lineTo(x2, y2 + h6 - radius.bottomLeft);
ctx.arc(x2 + radius.bottomLeft, y2 + h6 - radius.bottomLeft, radius.bottomLeft, PI, HALF_PI, true);
ctx.lineTo(x2 + w2 - radius.bottomRight, y2 + h6);
ctx.arc(x2 + w2 - radius.bottomRight, y2 + h6 - radius.bottomRight, radius.bottomRight, HALF_PI, 0, true);
ctx.lineTo(x2 + w2, y2 + radius.topRight);
ctx.arc(x2 + w2 - radius.topRight, y2 + radius.topRight, radius.topRight, 0, -HALF_PI, true);
ctx.lineTo(x2 + radius.topLeft, y2);
}
var LINE_HEIGHT = /^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/;
var FONT_STYLE = /^(normal|italic|initial|inherit|unset|(oblique( -?[0-9]?[0-9]deg)?))$/;
function toLineHeight(value, size) {
const matches = ("" + value).match(LINE_HEIGHT);
if (!matches || matches[1] === "normal") {
return size * 1.2;
}
value = +matches[2];
switch (matches[3]) {
case "px":
return value;
case "%":
value /= 100;
break;
}
return size * value;
}
var numberOrZero = (v2) => +v2 || 0;
function _readValueToProps(value, props) {
const ret = {};
const objProps = isObject(props);
const keys = objProps ? Object.keys(props) : props;
const read = isObject(value) ? objProps ? (prop) => valueOrDefault(value[prop], value[props[prop]]) : (prop) => value[prop] : () => value;
for (const prop of keys) {
ret[prop] = numberOrZero(read(prop));
}
return ret;
}
function toTRBL(value) {
return _readValueToProps(value, {
top: "y",
right: "x",
bottom: "y",
left: "x"
});
}
function toTRBLCorners(value) {
return _readValueToProps(value, [
"topLeft",
"topRight",
"bottomLeft",
"bottomRight"
]);
}
function toPadding(value) {
const obj = toTRBL(value);
obj.width = obj.left + obj.right;
obj.height = obj.top + obj.bottom;
return obj;
}
function toFont(options, fallback) {
options = options || {};
fallback = fallback || defaults2.font;
let size = valueOrDefault(options.size, fallback.size);
if (typeof size === "string") {
size = parseInt(size, 10);
}
let style = valueOrDefault(options.style, fallback.style);
if (style && !("" + style).match(FONT_STYLE)) {
console.warn('Invalid font style specified: "' + style + '"');
style = void 0;
}
const font = {
family: valueOrDefault(options.family, fallback.family),
lineHeight: toLineHeight(valueOrDefault(options.lineHeight, fallback.lineHeight), size),
size,
style,
weight: valueOrDefault(options.weight, fallback.weight),
string: ""
};
font.string = toFontString(font);
return font;
}
function resolve(inputs, context, index, info) {
let cacheable = true;
let i2, ilen, value;
for (i2 = 0, ilen = inputs.length; i2 < ilen; ++i2) {
value = inputs[i2];
if (value === void 0) {
continue;
}
if (context !== void 0 && typeof value === "function") {
value = value(context);
cacheable = false;
}
if (index !== void 0 && isArray(value)) {
value = value[index % value.length];
cacheable = false;
}
if (value !== void 0) {
if (info && !cacheable) {
info.cacheable = false;
}
return value;
}
}
}
function _addGrace(minmax, grace, beginAtZero) {
const { min, max } = minmax;
const change = toDimension(grace, (max - min) / 2);
const keepZero = (value, add) => beginAtZero && value === 0 ? 0 : value + add;
return {
min: keepZero(min, -Math.abs(change)),
max: keepZero(max, change)
};
}
function createContext(parentContext, context) {
return Object.assign(Object.create(parentContext), context);
}
function _createResolver(scopes, prefixes = [
""
], rootScopes, fallback, getTarget = () => scopes[0]) {
const finalRootScopes = rootScopes || scopes;
if (typeof fallback === "undefined") {
fallback = _resolve("_fallback", scopes);
}
const cache = {
[Symbol.toStringTag]: "Object",
_cacheable: true,
_scopes: scopes,
_rootScopes: finalRootScopes,
_fallback: fallback,
_getTarget: getTarget,
override: (scope) => _createResolver([
scope,
...scopes
], prefixes, finalRootScopes, fallback)
};
return new Proxy(cache, {
/**
* A trap for the delete operator.
*/
deleteProperty(target, prop) {
delete target[prop];
delete target._keys;
delete scopes[0][prop];
return true;
},
/**
* A trap for getting property values.
*/
get(target, prop) {
return _cached(target, prop, () => _resolveWithPrefixes(prop, prefixes, scopes, target));
},
/**
* A trap for Object.getOwnPropertyDescriptor.
* Also used by Object.hasOwnProperty.
*/
getOwnPropertyDescriptor(target, prop) {
return Reflect.getOwnPropertyDescriptor(target._scopes[0], prop);
},
/**
* A trap for Object.getPrototypeOf.
*/
getPrototypeOf() {
return Reflect.getPrototypeOf(scopes[0]);
},
/**
* A trap for the in operator.
*/
has(target, prop) {
return getKeysFromAllScopes(target).includes(prop);
},
/**
* A trap for Object.getOwnPropertyNames and Object.getOwnPropertySymbols.
*/
ownKeys(target) {
return getKeysFromAllScopes(target);
},
/**
* A trap for setting property values.
*/
set(target, prop, value) {
const storage = target._storage || (target._storage = getTarget());
target[prop] = storage[prop] = value;
delete target._keys;
return true;
}
});
}
function _attachContext(proxy, context, subProxy, descriptorDefaults) {
const cache = {
_cacheable: false,
_proxy: proxy,
_context: context,
_subProxy: subProxy,
_stack: /* @__PURE__ */ new Set(),
_descriptors: _descriptors(proxy, descriptorDefaults),
setContext: (ctx) => _attachContext(proxy, ctx, subProxy, descriptorDefaults),
override: (scope) => _attachContext(proxy.override(scope), context, subProxy, descriptorDefaults)
};
return new Proxy(cache, {
/**
* A trap for the delete operator.
*/
deleteProperty(target, prop) {
delete target[prop];
delete proxy[prop];
return true;
},
/**
* A trap for getting property values.
*/
get(target, prop, receiver) {
return _cached(target, prop, () => _resolveWithContext(target, prop, receiver));
},
/**
* A trap for Object.getOwnPropertyDescriptor.
* Also used by Object.hasOwnProperty.
*/
getOwnPropertyDescriptor(target, prop) {
return target._descriptors.allKeys ? Reflect.has(proxy, prop) ? {
enumerable: true,
configurable: true
} : void 0 : Reflect.getOwnPropertyDescriptor(proxy, prop);
},
/**
* A trap for Object.getPrototypeOf.
*/
getPrototypeOf() {
return Reflect.getPrototypeOf(proxy);
},
/**
* A trap for the in operator.
*/
has(target, prop) {
return Reflect.has(proxy, prop);
},
/**
* A trap for Object.getOwnPropertyNames and Object.getOwnPropertySymbols.
*/
ownKeys() {
return Reflect.ownKeys(proxy);
},
/**
* A trap for setting property values.
*/
set(target, prop, value) {
proxy[prop] = value;
delete target[prop];
return true;
}
});
}
function _descriptors(proxy, defaults3 = {
scriptable: true,
indexable: true
}) {
const { _scriptable = defaults3.scriptable, _indexable = defaults3.indexable, _allKeys = defaults3.allKeys } = proxy;
return {
allKeys: _allKeys,
scriptable: _scriptable,
indexable: _indexable,
isScriptable: isFunction(_scriptable) ? _scriptable : () => _scriptable,
isIndexable: isFunction(_indexable) ? _indexable : () => _indexable
};
}
var readKey = (prefix, name) => prefix ? prefix + _capitalize(name) : name;
var needsSubResolver = (prop, value) => isObject(value) && prop !== "adapters" && (Object.getPrototypeOf(value) === null || value.constructor === Object);
function _cached(target, prop, resolve2) {
if (Object.prototype.hasOwnProperty.call(target, prop) || prop === "constructor") {
return target[prop];
}
const value = resolve2();
target[prop] = value;
return value;
}
function _resolveWithContext(target, prop, receiver) {
const { _proxy, _context, _subProxy, _descriptors: descriptors2 } = target;
let value = _proxy[prop];
if (isFunction(value) && descriptors2.isScriptable(prop)) {
value = _resolveScriptable(prop, value, target, receiver);
}
if (isArray(value) && value.length) {
value = _resolveArray(prop, value, target, descriptors2.isIndexable);
}
if (needsSubResolver(prop, value)) {
value = _attachContext(value, _context, _subProxy && _subProxy[prop], descriptors2);
}
return value;
}
function _resolveScriptable(prop, getValue, target, receiver) {
const { _proxy, _context, _subProxy, _stack } = target;
if (_stack.has(prop)) {
throw new Error("Recursion detected: " + Array.from(_stack).join("->") + "->" + prop);
}
_stack.add(prop);
let value = getValue(_context, _subProxy || receiver);
_stack.delete(prop);
if (needsSubResolver(prop, value)) {
value = createSubResolver(_proxy._scopes, _proxy, prop, value);
}
return value;
}
function _resolveArray(prop, value, target, isIndexable) {
const { _proxy, _context, _subProxy, _descriptors: descriptors2 } = target;
if (typeof _context.index !== "undefined" && isIndexable(prop)) {
return value[_context.index % value.length];
} else if (isObject(value[0])) {
const arr = value;
const scopes = _proxy._scopes.filter((s2) => s2 !== arr);
value = [];
for (const item of arr) {
const resolver = createSubResolver(scopes, _proxy, prop, item);
value.push(_attachContext(resolver, _context, _subProxy && _subProxy[prop], descriptors2));
}
}
return value;
}
function resolveFallback(fallback, prop, value) {
return isFunction(fallback) ? fallback(prop, value) : fallback;
}
var getScope = (key, parent) => key === true ? parent : typeof key === "string" ? resolveObjectKey(parent, key) : void 0;
function addScopes(set2, parentScopes, key, parentFallback, value) {
for (const parent of parentScopes) {
const scope = getScope(key, parent);
if (scope) {
set2.add(scope);
const fallback = resolveFallback(scope._fallback, key, value);
if (typeof fallback !== "undefined" && fallback !== key && fallback !== parentFallback) {
return fallback;
}
} else if (scope === false && typeof parentFallback !== "undefined" && key !== parentFallback) {
return null;
}
}
return false;
}
function createSubResolver(parentScopes, resolver, prop, value) {
const rootScopes = resolver._rootScopes;
const fallback = resolveFallback(resolver._fallback, prop, value);
const allScopes = [
...parentScopes,
...rootScopes
];
const set2 = /* @__PURE__ */ new Set();
set2.add(value);
let key = addScopesFromKey(set2, allScopes, prop, fallback || prop, value);
if (key === null) {
return false;
}
if (typeof fallback !== "undefined" && fallback !== prop) {
key = addScopesFromKey(set2, allScopes, fallback, key, value);
if (key === null) {
return false;
}
}
return _createResolver(Array.from(set2), [
""
], rootScopes, fallback, () => subGetTarget(resolver, prop, value));
}
function addScopesFromKey(set2, allScopes, key, fallback, item) {
while (key) {
key = addScopes(set2, allScopes, key, fallback, item);
}
return key;
}
function subGetTarget(resolver, prop, value) {
const parent = resolver._getTarget();
if (!(prop in parent)) {
parent[prop] = {};
}
const target = parent[prop];
if (isArray(target) && isObject(value)) {
return value;
}
return target || {};
}
function _resolveWithPrefixes(prop, prefixes, scopes, proxy) {
let value;
for (const prefix of prefixes) {
value = _resolve(readKey(prefix, prop), scopes);
if (typeof value !== "undefined") {
return needsSubResolver(prop, value) ? createSubResolver(scopes, proxy, prop, value) : value;
}
}
}
function _resolve(key, scopes) {
for (const scope of scopes) {
if (!scope) {
continue;
}
const value = scope[key];
if (typeof value !== "undefined") {
return value;
}
}
}
function getKeysFromAllScopes(target) {
let keys = target._keys;
if (!keys) {
keys = target._keys = resolveKeysFromAllScopes(target._scopes);
}
return keys;
}
function resolveKeysFromAllScopes(scopes) {
const set2 = /* @__PURE__ */ new Set();
for (const scope of scopes) {
for (const key of Object.keys(scope).filter((k) => !k.startsWith("_"))) {
set2.add(key);
}
}
return Array.from(set2);
}
var EPSILON = Number.EPSILON || 1e-14;
function _isDomSupported() {
return typeof window !== "undefined" && typeof document !== "undefined";
}
function _getParentNode(domNode) {
let parent = domNode.parentNode;
if (parent && parent.toString() === "[object ShadowRoot]") {
parent = parent.host;
}
return parent;
}
function parseMaxStyle(styleValue, node, parentProperty) {
let valueInPixels;
if (typeof styleValue === "string") {
valueInPixels = parseInt(styleValue, 10);
if (styleValue.indexOf("%") !== -1) {
valueInPixels = valueInPixels / 100 * node.parentNode[parentProperty];
}
} else {
valueInPixels = styleValue;
}
return valueInPixels;
}
var getComputedStyle2 = (element) => element.ownerDocument.defaultView.getComputedStyle(element, null);
function getStyle(el, property) {
return getComputedStyle2(el).getPropertyValue(property);
}
var positions = [
"top",
"right",
"bottom",
"left"
];
function getPositionedStyle(styles, style, suffix) {
const result = {};
suffix = suffix ? "-" + suffix : "";
for (let i2 = 0; i2 < 4; i2++) {
const pos = positions[i2];
result[pos] = parseFloat(styles[style + "-" + pos + suffix]) || 0;
}
result.width = result.left + result.right;
result.height = result.top + result.bottom;
return result;
}
var useOffsetPos = (x2, y2, target) => (x2 > 0 || y2 > 0) && (!target || !target.shadowRoot);
function getCanvasPosition(e2, canvas) {
const touches = e2.touches;
const source = touches && touches.length ? touches[0] : e2;
const { offsetX, offsetY } = source;
let box = false;
let x2, y2;
if (useOffsetPos(offsetX, offsetY, e2.target)) {
x2 = offsetX;
y2 = offsetY;
} else {
const rect = canvas.getBoundingClientRect();
x2 = source.clientX - rect.left;
y2 = source.clientY - rect.top;
box = true;
}
return {
x: x2,
y: y2,
box
};
}
function getRelativePosition(event, chart) {
if ("native" in event) {
return event;
}
const { canvas, currentDevicePixelRatio } = chart;
const style = getComputedStyle2(canvas);
const borderBox = style.boxSizing === "border-box";
const paddings = getPositionedStyle(style, "padding");
const borders = getPositionedStyle(style, "border", "width");
const { x: x2, y: y2, box } = getCanvasPosition(event, canvas);
const xOffset = paddings.left + (box && borders.left);
const yOffset = paddings.top + (box && borders.top);
let { width, height } = chart;
if (borderBox) {
width -= paddings.width + borders.width;
height -= paddings.height + borders.height;
}
return {
x: Math.round((x2 - xOffset) / width * canvas.width / currentDevicePixelRatio),
y: Math.round((y2 - yOffset) / height * canvas.height / currentDevicePixelRatio)
};
}
function getContainerSize(canvas, width, height) {
let maxWidth, maxHeight;
if (width === void 0 || height === void 0) {
const container = canvas && _getParentNode(canvas);
if (!container) {
width = canvas.clientWidth;
height = canvas.clientHeight;
} else {
const rect = container.getBoundingClientRect();
const containerStyle = getComputedStyle2(container);
const containerBorder = getPositionedStyle(containerStyle, "border", "width");
const containerPadding = getPositionedStyle(containerStyle, "padding");
width = rect.width - containerPadding.width - containerBorder.width;
height = rect.height - containerPadding.height - containerBorder.height;
maxWidth = parseMaxStyle(containerStyle.maxWidth, container, "clientWidth");
maxHeight = parseMaxStyle(containerStyle.maxHeight, container, "clientHeight");
}
}
return {
width,
height,
maxWidth: maxWidth || INFINITY,
maxHeight: maxHeight || INFINITY
};
}
var round1 = (v2) => Math.round(v2 * 10) / 10;
function getMaximumSize(canvas, bbWidth, bbHeight, aspectRatio) {
const style = getComputedStyle2(canvas);
const margins = getPositionedStyle(style, "margin");
const maxWidth = parseMaxStyle(style.maxWidth, canvas, "clientWidth") || INFINITY;
const maxHeight = parseMaxStyle(style.maxHeight, canvas, "clientHeight") || INFINITY;
const containerSize = getContainerSize(canvas, bbWidth, bbHeight);
let { width, height } = containerSize;
if (style.boxSizing === "content-box") {
const borders = getPositionedStyle(style, "border", "width");
const paddings = getPositionedStyle(style, "padding");
width -= paddings.width + borders.width;
height -= paddings.height + borders.height;
}
width = Math.max(0, width - margins.width);
height = Math.max(0, aspectRatio ? width / aspectRatio : height - margins.height);
width = round1(Math.min(width, maxWidth, containerSize.maxWidth));
height = round1(Math.min(height, maxHeight, containerSize.maxHeight));
if (width && !height) {
height = round1(width / 2);
}
const maintainHeight = bbWidth !== void 0 || bbHeight !== void 0;
if (maintainHeight && aspectRatio && containerSize.height && height > containerSize.height) {
height = containerSize.height;
width = round1(Math.floor(height * aspectRatio));
}
return {
width,
height
};
}
function retinaScale(chart, forceRatio, forceStyle) {
const pixelRatio = forceRatio || 1;
const deviceHeight = Math.floor(chart.height * pixelRatio);
const deviceWidth = Math.floor(chart.width * pixelRatio);
chart.height = Math.floor(chart.height);
chart.width = Math.floor(chart.width);
const canvas = chart.canvas;
if (canvas.style && (forceStyle || !canvas.style.height && !canvas.style.width)) {
canvas.style.height = `${chart.height}px`;
canvas.style.width = `${chart.width}px`;
}
if (chart.currentDevicePixelRatio !== pixelRatio || canvas.height !== deviceHeight || canvas.width !== deviceWidth) {
chart.currentDevicePixelRatio = pixelRatio;
canvas.height = deviceHeight;
canvas.width = deviceWidth;
chart.ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
return true;
}
return false;
}
var supportsEventListenerOptions = function() {
let passiveSupported = false;
try {
const options = {
get passive() {
passiveSupported = true;
return false;
}
};
if (_isDomSupported()) {
window.addEventListener("test", null, options);
window.removeEventListener("test", null, options);
}
} catch (e2) {
}
return passiveSupported;
}();
function readUsedSize(element, property) {
const value = getStyle(element, property);
const matches = value && value.match(/^(\d+)(\.\d+)?px$/);
return matches ? +matches[1] : void 0;
}
var getRightToLeftAdapter = function(rectX, width) {
return {
x(x2) {
return rectX + rectX + width - x2;
},
setWidth(w2) {
width = w2;
},
textAlign(align) {
if (align === "center") {
return align;
}
return align === "right" ? "left" : "right";
},
xPlus(x2, value) {
return x2 - value;
},
leftForLtr(x2, itemWidth) {
return x2 - itemWidth;
}
};
};
var getLeftToRightAdapter = function() {
return {
x(x2) {
return x2;
},
setWidth(w2) {
},
textAlign(align) {
return align;
},
xPlus(x2, value) {
return x2 + value;
},
leftForLtr(x2, _itemWidth) {
return x2;
}
};
};
function getRtlAdapter(rtl, rectX, width) {
return rtl ? getRightToLeftAdapter(rectX, width) : getLeftToRightAdapter();
}
function overrideTextDirection(ctx, direction) {
let style, original;
if (direction === "ltr" || direction === "rtl") {
style = ctx.canvas.style;
original = [
style.getPropertyValue("direction"),
style.getPropertyPriority("direction")
];
style.setProperty("direction", direction, "important");
ctx.prevTextDirection = original;
}
}
function restoreTextDirection(ctx, original) {
if (original !== void 0) {
delete ctx.prevTextDirection;
ctx.canvas.style.setProperty("direction", original[0], original[1]);
}
}
// node_modules/.pnpm/chart.js@4.4.4/node_modules/chart.js/dist/chart.js
var Animator = class {
constructor() {
this._request = null;
this._charts = /* @__PURE__ */ new Map();
this._running = false;
this._lastDate = void 0;
}
_notify(chart, anims, date, type) {
const callbacks = anims.listeners[type];
const numSteps = anims.duration;
callbacks.forEach((fn2) => fn2({
chart,
initial: anims.initial,
numSteps,
currentStep: Math.min(date - anims.start, numSteps)
}));
}
_refresh() {
if (this._request) {
return;
}
this._running = true;
this._request = requestAnimFrame.call(window, () => {
this._update();
this._request = null;
if (this._running) {
this._refresh();
}
});
}
_update(date = Date.now()) {
let remaining = 0;
this._charts.forEach((anims, chart) => {
if (!anims.running || !anims.items.length) {
return;
}
const items = anims.items;
let i2 = items.length - 1;
let draw = false;
let item;
for (; i2 >= 0; --i2) {
item = items[i2];
if (item._active) {
if (item._total > anims.duration) {
anims.duration = item._total;
}
item.tick(date);
draw = true;
} else {
items[i2] = items[items.length - 1];
items.pop();
}
}
if (draw) {
chart.draw();
this._notify(chart, anims, date, "progress");
}
if (!items.length) {
anims.running = false;
this._notify(chart, anims, date, "complete");
anims.initial = false;
}
remaining += items.length;
});
this._lastDate = date;
if (remaining === 0) {
this._running = false;
}
}
_getAnims(chart) {
const charts = this._charts;
let anims = charts.get(chart);
if (!anims) {
anims = {
running: false,
initial: true,
items: [],
listeners: {
complete: [],
progress: []
}
};
charts.set(chart, anims);
}
return anims;
}
listen(chart, event, cb) {
this._getAnims(chart).listeners[event].push(cb);
}
add(chart, items) {
if (!items || !items.length) {
return;
}
this._getAnims(chart).items.push(...items);
}
has(chart) {
return this._getAnims(chart).items.length > 0;
}
start(chart) {
const anims = this._charts.get(chart);
if (!anims) {
return;
}
anims.running = true;
anims.start = Date.now();
anims.duration = anims.items.reduce((acc, cur) => Math.max(acc, cur._duration), 0);
this._refresh();
}
running(chart) {
if (!this._running) {
return false;
}
const anims = this._charts.get(chart);
if (!anims || !anims.running || !anims.items.length) {
return false;
}
return true;
}
stop(chart) {
const anims = this._charts.get(chart);
if (!anims || !anims.items.length) {
return;
}
const items = anims.items;
let i2 = items.length - 1;
for (; i2 >= 0; --i2) {
items[i2].cancel();
}
anims.items = [];
this._notify(chart, anims, Date.now(), "complete");
}
remove(chart) {
return this._charts.delete(chart);
}
};
var animator = /* @__PURE__ */ new Animator();
var transparent = "transparent";
var interpolators = {
boolean(from2, to2, factor) {
return factor > 0.5 ? to2 : from2;
},
color(from2, to2, factor) {
const c0 = color(from2 || transparent);
const c1 = c0.valid && color(to2 || transparent);
return c1 && c1.valid ? c1.mix(c0, factor).hexString() : to2;
},
number(from2, to2, factor) {
return from2 + (to2 - from2) * factor;
}
};
var Animation = class {
constructor(cfg, target, prop, to2) {
const currentValue = target[prop];
to2 = resolve([
cfg.to,
to2,
currentValue,
cfg.from
]);
const from2 = resolve([
cfg.from,
currentValue,
to2
]);
this._active = true;
this._fn = cfg.fn || interpolators[cfg.type || typeof from2];
this._easing = effects[cfg.easing] || effects.linear;
this._start = Math.floor(Date.now() + (cfg.delay || 0));
this._duration = this._total = Math.floor(cfg.duration);
this._loop = !!cfg.loop;
this._target = target;
this._prop = prop;
this._from = from2;
this._to = to2;
this._promises = void 0;
}
active() {
return this._active;
}
update(cfg, to2, date) {
if (this._active) {
this._notify(false);
const currentValue = this._target[this._prop];
const elapsed = date - this._start;
const remain = this._duration - elapsed;
this._start = date;
this._duration = Math.floor(Math.max(remain, cfg.duration));
this._total += elapsed;
this._loop = !!cfg.loop;
this._to = resolve([
cfg.to,
to2,
currentValue,
cfg.from
]);
this._from = resolve([
cfg.from,
currentValue,
to2
]);
}
}
cancel() {
if (this._active) {
this.tick(Date.now());
this._active = false;
this._notify(false);
}
}
tick(date) {
const elapsed = date - this._start;
const duration = this._duration;
const prop = this._prop;
const from2 = this._from;
const loop = this._loop;
const to2 = this._to;
let factor;
this._active = from2 !== to2 && (loop || elapsed < duration);
if (!this._active) {
this._target[prop] = to2;
this._notify(true);
return;
}
if (elapsed < 0) {
this._target[prop] = from2;
return;
}
factor = elapsed / duration % 2;
factor = loop && factor > 1 ? 2 - factor : factor;
factor = this._easing(Math.min(1, Math.max(0, factor)));
this._target[prop] = this._fn(from2, to2, factor);
}
wait() {
const promises = this._promises || (this._promises = []);
return new Promise((res, rej) => {
promises.push({
res,
rej
});
});
}
_notify(resolved) {
const method = resolved ? "res" : "rej";
const promises = this._promises || [];
for (let i2 = 0; i2 < promises.length; i2++) {
promises[i2][method]();
}
}
};
var Animations = class {
constructor(chart, config) {
this._chart = chart;
this._properties = /* @__PURE__ */ new Map();
this.configure(config);
}
configure(config) {
if (!isObject(config)) {
return;
}
const animationOptions = Object.keys(defaults2.animation);
const animatedProps = this._properties;
Object.getOwnPropertyNames(config).forEach((key) => {
const cfg = config[key];
if (!isObject(cfg)) {
return;
}
const resolved = {};
for (const option of animationOptions) {
resolved[option] = cfg[option];
}
(isArray(cfg.properties) && cfg.properties || [
key
]).forEach((prop) => {
if (prop === key || !animatedProps.has(prop)) {
animatedProps.set(prop, resolved);
}
});
});
}
_animateOptions(target, values) {
const newOptions = values.options;
const options = resolveTargetOptions(target, newOptions);
if (!options) {
return [];
}
const animations = this._createAnimations(options, newOptions);
if (newOptions.$shared) {
awaitAll(target.options.$animations, newOptions).then(() => {
target.options = newOptions;
}, () => {
});
}
return animations;
}
_createAnimations(target, values) {
const animatedProps = this._properties;
const animations = [];
const running = target.$animations || (target.$animations = {});
const props = Object.keys(values);
const date = Date.now();
let i2;
for (i2 = props.length - 1; i2 >= 0; --i2) {
const prop = props[i2];
if (prop.charAt(0) === "$") {
continue;
}
if (prop === "options") {
animations.push(...this._animateOptions(target, values));
continue;
}
const value = values[prop];
let animation = running[prop];
const cfg = animatedProps.get(prop);
if (animation) {
if (cfg && animation.active()) {
animation.update(cfg, value, date);
continue;
} else {
animation.cancel();
}
}
if (!cfg || !cfg.duration) {
target[prop] = value;
continue;
}
running[prop] = animation = new Animation(cfg, target, prop, value);
animations.push(animation);
}
return animations;
}
update(target, values) {
if (this._properties.size === 0) {
Object.assign(target, values);
return;
}
const animations = this._createAnimations(target, values);
if (animations.length) {
animator.add(this._chart, animations);
return true;
}
}
};
function awaitAll(animations, properties) {
const running = [];
const keys = Object.keys(properties);
for (let i2 = 0; i2 < keys.length; i2++) {
const anim = animations[keys[i2]];
if (anim && anim.active()) {
running.push(anim.wait());
}
}
return Promise.all(running);
}
function resolveTargetOptions(target, newOptions) {
if (!newOptions) {
return;
}
let options = target.options;
if (!options) {
target.options = newOptions;
return;
}
if (options.$shared) {
target.options = options = Object.assign({}, options, {
$shared: false,
$animations: {}
});
}
return options;
}
function scaleClip(scale, allowedOverflow) {
const opts = scale && scale.options || {};
const reverse = opts.reverse;
const min = opts.min === void 0 ? allowedOverflow : 0;
const max = opts.max === void 0 ? allowedOverflow : 0;
return {
start: reverse ? max : min,
end: reverse ? min : max
};
}
function defaultClip(xScale, yScale, allowedOverflow) {
if (allowedOverflow === false) {
return false;
}
const x2 = scaleClip(xScale, allowedOverflow);
const y2 = scaleClip(yScale, allowedOverflow);
return {
top: y2.end,
right: x2.end,
bottom: y2.start,
left: x2.start
};
}
function toClip(value) {
let t3, r2, b2, l2;
if (isObject(value)) {
t3 = value.top;
r2 = value.right;
b2 = value.bottom;
l2 = value.left;
} else {
t3 = r2 = b2 = l2 = value;
}
return {
top: t3,
right: r2,
bottom: b2,
left: l2,
disabled: value === false
};
}
function getSortedDatasetIndices(chart, filterVisible) {
const keys = [];
const metasets = chart._getSortedDatasetMetas(filterVisible);
let i2, ilen;
for (i2 = 0, ilen = metasets.length; i2 < ilen; ++i2) {
keys.push(metasets[i2].index);
}
return keys;
}
function applyStack(stack, value, dsIndex, options = {}) {
const keys = stack.keys;
const singleMode = options.mode === "single";
let i2, ilen, datasetIndex, otherValue;
if (value === null) {
return;
}
for (i2 = 0, ilen = keys.length; i2 < ilen; ++i2) {
datasetIndex = +keys[i2];
if (datasetIndex === dsIndex) {
if (options.all) {
continue;
}
break;
}
otherValue = stack.values[datasetIndex];
if (isNumberFinite(otherValue) && (singleMode || value === 0 || sign(value) === sign(otherValue))) {
value += otherValue;
}
}
return value;
}
function convertObjectDataToArray(data, meta) {
const { iScale, vScale } = meta;
const iAxisKey = iScale.axis === "x" ? "x" : "y";
const vAxisKey = vScale.axis === "x" ? "x" : "y";
const keys = Object.keys(data);
const adata = new Array(keys.length);
let i2, ilen, key;
for (i2 = 0, ilen = keys.length; i2 < ilen; ++i2) {
key = keys[i2];
adata[i2] = {
[iAxisKey]: key,
[vAxisKey]: data[key]
};
}
return adata;
}
function isStacked(scale, meta) {
const stacked = scale && scale.options.stacked;
return stacked || stacked === void 0 && meta.stack !== void 0;
}
function getStackKey(indexScale, valueScale, meta) {
return `${indexScale.id}.${valueScale.id}.${meta.stack || meta.type}`;
}
function getUserBounds(scale) {
const { min, max, minDefined, maxDefined } = scale.getUserBounds();
return {
min: minDefined ? min : Number.NEGATIVE_INFINITY,
max: maxDefined ? max : Number.POSITIVE_INFINITY
};
}
function getOrCreateStack(stacks, stackKey, indexValue) {
const subStack = stacks[stackKey] || (stacks[stackKey] = {});
return subStack[indexValue] || (subStack[indexValue] = {});
}
function getLastIndexInStack(stack, vScale, positive, type) {
for (const meta of vScale.getMatchingVisibleMetas(type).reverse()) {
const value = stack[meta.index];
if (positive && value > 0 || !positive && value < 0) {
return meta.index;
}
}
return null;
}
function updateStacks(controller, parsed) {
const { chart, _cachedMeta: meta } = controller;
const stacks = chart._stacks || (chart._stacks = {});
const { iScale, vScale, index: datasetIndex } = meta;
const iAxis = iScale.axis;
const vAxis = vScale.axis;
const key = getStackKey(iScale, vScale, meta);
const ilen = parsed.length;
let stack;
for (let i2 = 0; i2 < ilen; ++i2) {
const item = parsed[i2];
const { [iAxis]: index, [vAxis]: value } = item;
const itemStacks = item._stacks || (item._stacks = {});
stack = itemStacks[vAxis] = getOrCreateStack(stacks, key, index);
stack[datasetIndex] = value;
stack._top = getLastIndexInStack(stack, vScale, true, meta.type);
stack._bottom = getLastIndexInStack(stack, vScale, false, meta.type);
const visualValues = stack._visualValues || (stack._visualValues = {});
visualValues[datasetIndex] = value;
}
}
function getFirstScaleId(chart, axis) {
const scales = chart.scales;
return Object.keys(scales).filter((key) => scales[key].axis === axis).shift();
}
function createDatasetContext(parent, index) {
return createContext(parent, {
active: false,
dataset: void 0,
datasetIndex: index,
index,
mode: "default",
type: "dataset"
});
}
function createDataContext(parent, index, element) {
return createContext(parent, {
active: false,
dataIndex: index,
parsed: void 0,
raw: void 0,
element,
index,
mode: "default",
type: "data"
});
}
function clearStacks(meta, items) {
const datasetIndex = meta.controller.index;
const axis = meta.vScale && meta.vScale.axis;
if (!axis) {
return;
}
items = items || meta._parsed;
for (const parsed of items) {
const stacks = parsed._stacks;
if (!stacks || stacks[axis] === void 0 || stacks[axis][datasetIndex] === void 0) {
return;
}
delete stacks[axis][datasetIndex];
if (stacks[axis]._visualValues !== void 0 && stacks[axis]._visualValues[datasetIndex] !== void 0) {
delete stacks[axis]._visualValues[datasetIndex];
}
}
}
var isDirectUpdateMode = (mode) => mode === "reset" || mode === "none";
var cloneIfNotShared = (cached, shared) => shared ? cached : Object.assign({}, cached);
var createStack = (canStack, meta, chart) => canStack && !meta.hidden && meta._stacked && {
keys: getSortedDatasetIndices(chart, true),
values: null
};
var DatasetController = class {
constructor(chart, datasetIndex) {
this.chart = chart;
this._ctx = chart.ctx;
this.index = datasetIndex;
this._cachedDataOpts = {};
this._cachedMeta = this.getMeta();
this._type = this._cachedMeta.type;
this.options = void 0;
this._parsing = false;
this._data = void 0;
this._objectData = void 0;
this._sharedOptions = void 0;
this._drawStart = void 0;
this._drawCount = void 0;
this.enableOptionSharing = false;
this.supportsDecimation = false;
this.$context = void 0;
this._syncList = [];
this.datasetElementType = new.target.datasetElementType;
this.dataElementType = new.target.dataElementType;
this.initialize();
}
initialize() {
const meta = this._cachedMeta;
this.configure();
this.linkScales();
meta._stacked = isStacked(meta.vScale, meta);
this.addElements();
if (this.options.fill && !this.chart.isPluginEnabled("filler")) {
console.warn("Tried to use the 'fill' option without the 'Filler' plugin enabled. Please import and register the 'Filler' plugin and make sure it is not disabled in the options");
}
}
updateIndex(datasetIndex) {
if (this.index !== datasetIndex) {
clearStacks(this._cachedMeta);
}
this.index = datasetIndex;
}
linkScales() {
const chart = this.chart;
const meta = this._cachedMeta;
const dataset = this.getDataset();
const chooseId = (axis, x2, y2, r2) => axis === "x" ? x2 : axis === "r" ? r2 : y2;
const xid = meta.xAxisID = valueOrDefault(dataset.xAxisID, getFirstScaleId(chart, "x"));
const yid = meta.yAxisID = valueOrDefault(dataset.yAxisID, getFirstScaleId(chart, "y"));
const rid = meta.rAxisID = valueOrDefault(dataset.rAxisID, getFirstScaleId(chart, "r"));
const indexAxis = meta.indexAxis;
const iid = meta.iAxisID = chooseId(indexAxis, xid, yid, rid);
const vid = meta.vAxisID = chooseId(indexAxis, yid, xid, rid);
meta.xScale = this.getScaleForId(xid);
meta.yScale = this.getScaleForId(yid);
meta.rScale = this.getScaleForId(rid);
meta.iScale = this.getScaleForId(iid);
meta.vScale = this.getScaleForId(vid);
}
getDataset() {
return this.chart.data.datasets[this.index];
}
getMeta() {
return this.chart.getDatasetMeta(this.index);
}
getScaleForId(scaleID) {
return this.chart.scales[scaleID];
}
_getOtherScale(scale) {
const meta = this._cachedMeta;
return scale === meta.iScale ? meta.vScale : meta.iScale;
}
reset() {
this._update("reset");
}
_destroy() {
const meta = this._cachedMeta;
if (this._data) {
unlistenArrayEvents(this._data, this);
}
if (meta._stacked) {
clearStacks(meta);
}
}
_dataCheck() {
const dataset = this.getDataset();
const data = dataset.data || (dataset.data = []);
const _data = this._data;
if (isObject(data)) {
const meta = this._cachedMeta;
this._data = convertObjectDataToArray(data, meta);
} else if (_data !== data) {
if (_data) {
unlistenArrayEvents(_data, this);
const meta = this._cachedMeta;
clearStacks(meta);
meta._parsed = [];
}
if (data && Object.isExtensible(data)) {
listenArrayEvents(data, this);
}
this._syncList = [];
this._data = data;
}
}
addElements() {
const meta = this._cachedMeta;
this._dataCheck();
if (this.datasetElementType) {
meta.dataset = new this.datasetElementType();
}
}
buildOrUpdateElements(resetNewElements) {
const meta = this._cachedMeta;
const dataset = this.getDataset();
let stackChanged = false;
this._dataCheck();
const oldStacked = meta._stacked;
meta._stacked = isStacked(meta.vScale, meta);
if (meta.stack !== dataset.stack) {
stackChanged = true;
clearStacks(meta);
meta.stack = dataset.stack;
}
this._resyncElements(resetNewElements);
if (stackChanged || oldStacked !== meta._stacked) {
updateStacks(this, meta._parsed);
}
}
configure() {
const config = this.chart.config;
const scopeKeys = config.datasetScopeKeys(this._type);
const scopes = config.getOptionScopes(this.getDataset(), scopeKeys, true);
this.options = config.createResolver(scopes, this.getContext());
this._parsing = this.options.parsing;
this._cachedDataOpts = {};
}
parse(start, count) {
const { _cachedMeta: meta, _data: data } = this;
const { iScale, _stacked } = meta;
const iAxis = iScale.axis;
let sorted = start === 0 && count === data.length ? true : meta._sorted;
let prev = start > 0 && meta._parsed[start - 1];
let i2, cur, parsed;
if (this._parsing === false) {
meta._parsed = data;
meta._sorted = true;
parsed = data;
} else {
if (isArray(data[start])) {
parsed = this.parseArrayData(meta, data, start, count);
} else if (isObject(data[start])) {
parsed = this.parseObjectData(meta, data, start, count);
} else {
parsed = this.parsePrimitiveData(meta, data, start, count);
}
const isNotInOrderComparedToPrev = () => cur[iAxis] === null || prev && cur[iAxis] < prev[iAxis];
for (i2 = 0; i2 < count; ++i2) {
meta._parsed[i2 + start] = cur = parsed[i2];
if (sorted) {
if (isNotInOrderComparedToPrev()) {
sorted = false;
}
prev = cur;
}
}
meta._sorted = sorted;
}
if (_stacked) {
updateStacks(this, parsed);
}
}
parsePrimitiveData(meta, data, start, count) {
const { iScale, vScale } = meta;
const iAxis = iScale.axis;
const vAxis = vScale.axis;
const labels = iScale.getLabels();
const singleScale = iScale === vScale;
const parsed = new Array(count);
let i2, ilen, index;
for (i2 = 0, ilen = count; i2 < ilen; ++i2) {
index = i2 + start;
parsed[i2] = {
[iAxis]: singleScale || iScale.parse(labels[index], index),
[vAxis]: vScale.parse(data[index], index)
};
}
return parsed;
}
parseArrayData(meta, data, start, count) {
const { xScale, yScale } = meta;
const parsed = new Array(count);
let i2, ilen, index, item;
for (i2 = 0, ilen = count; i2 < ilen; ++i2) {
index = i2 + start;
item = data[index];
parsed[i2] = {
x: xScale.parse(item[0], index),
y: yScale.parse(item[1], index)
};
}
return parsed;
}
parseObjectData(meta, data, start, count) {
const { xScale, yScale } = meta;
const { xAxisKey = "x", yAxisKey = "y" } = this._parsing;
const parsed = new Array(count);
let i2, ilen, index, item;
for (i2 = 0, ilen = count; i2 < ilen; ++i2) {
index = i2 + start;
item = data[index];
parsed[i2] = {
x: xScale.parse(resolveObjectKey(item, xAxisKey), index),
y: yScale.parse(resolveObjectKey(item, yAxisKey), index)
};
}
return parsed;
}
getParsed(index) {
return this._cachedMeta._parsed[index];
}
getDataElement(index) {
return this._cachedMeta.data[index];
}
applyStack(scale, parsed, mode) {
const chart = this.chart;
const meta = this._cachedMeta;
const value = parsed[scale.axis];
const stack = {
keys: getSortedDatasetIndices(chart, true),
values: parsed._stacks[scale.axis]._visualValues
};
return applyStack(stack, value, meta.index, {
mode
});
}
updateRangeFromParsed(range, scale, parsed, stack) {
const parsedValue = parsed[scale.axis];
let value = parsedValue === null ? NaN : parsedValue;
const values = stack && parsed._stacks[scale.axis];
if (stack && values) {
stack.values = values;
value = applyStack(stack, parsedValue, this._cachedMeta.index);
}
range.min = Math.min(range.min, value);
range.max = Math.max(range.max, value);
}
getMinMax(scale, canStack) {
const meta = this._cachedMeta;
const _parsed = meta._parsed;
const sorted = meta._sorted && scale === meta.iScale;
const ilen = _parsed.length;
const otherScale = this._getOtherScale(scale);
const stack = createStack(canStack, meta, this.chart);
const range = {
min: Number.POSITIVE_INFINITY,
max: Number.NEGATIVE_INFINITY
};
const { min: otherMin, max: otherMax } = getUserBounds(otherScale);
let i2, parsed;
function _skip() {
parsed = _parsed[i2];
const otherValue = parsed[otherScale.axis];
return !isNumberFinite(parsed[scale.axis]) || otherMin > otherValue || otherMax < otherValue;
}
for (i2 = 0; i2 < ilen; ++i2) {
if (_skip()) {
continue;
}
this.updateRangeFromParsed(range, scale, parsed, stack);
if (sorted) {
break;
}
}
if (sorted) {
for (i2 = ilen - 1; i2 >= 0; --i2) {
if (_skip()) {
continue;
}
this.updateRangeFromParsed(range, scale, parsed, stack);
break;
}
}
return range;
}
getAllParsedValues(scale) {
const parsed = this._cachedMeta._parsed;
const values = [];
let i2, ilen, value;
for (i2 = 0, ilen = parsed.length; i2 < ilen; ++i2) {
value = parsed[i2][scale.axis];
if (isNumberFinite(value)) {
values.push(value);
}
}
return values;
}
getMaxOverflow() {
return false;
}
getLabelAndValue(index) {
const meta = this._cachedMeta;
const iScale = meta.iScale;
const vScale = meta.vScale;
const parsed = this.getParsed(index);
return {
label: iScale ? "" + iScale.getLabelForValue(parsed[iScale.axis]) : "",
value: vScale ? "" + vScale.getLabelForValue(parsed[vScale.axis]) : ""
};
}
_update(mode) {
const meta = this._cachedMeta;
this.update(mode || "default");
meta._clip = toClip(valueOrDefault(this.options.clip, defaultClip(meta.xScale, meta.yScale, this.getMaxOverflow())));
}
update(mode) {
}
draw() {
const ctx = this._ctx;
const chart = this.chart;
const meta = this._cachedMeta;
const elements = meta.data || [];
const area = chart.chartArea;
const active = [];
const start = this._drawStart || 0;
const count = this._drawCount || elements.length - start;
const drawActiveElementsOnTop = this.options.drawActiveElementsOnTop;
let i2;
if (meta.dataset) {
meta.dataset.draw(ctx, area, start, count);
}
for (i2 = start; i2 < start + count; ++i2) {
const element = elements[i2];
if (element.hidden) {
continue;
}
if (element.active && drawActiveElementsOnTop) {
active.push(element);
} else {
element.draw(ctx, area);
}
}
for (i2 = 0; i2 < active.length; ++i2) {
active[i2].draw(ctx, area);
}
}
getStyle(index, active) {
const mode = active ? "active" : "default";
return index === void 0 && this._cachedMeta.dataset ? this.resolveDatasetElementOptions(mode) : this.resolveDataElementOptions(index || 0, mode);
}
getContext(index, active, mode) {
const dataset = this.getDataset();
let context;
if (index >= 0 && index < this._cachedMeta.data.length) {
const element = this._cachedMeta.data[index];
context = element.$context || (element.$context = createDataContext(this.getContext(), index, element));
context.parsed = this.getParsed(index);
context.raw = dataset.data[index];
context.index = context.dataIndex = index;
} else {
context = this.$context || (this.$context = createDatasetContext(this.chart.getContext(), this.index));
context.dataset = dataset;
context.index = context.datasetIndex = this.index;
}
context.active = !!active;
context.mode = mode;
return context;
}
resolveDatasetElementOptions(mode) {
return this._resolveElementOptions(this.datasetElementType.id, mode);
}
resolveDataElementOptions(index, mode) {
return this._resolveElementOptions(this.dataElementType.id, mode, index);
}
_resolveElementOptions(elementType, mode = "default", index) {
const active = mode === "active";
const cache = this._cachedDataOpts;
const cacheKey = elementType + "-" + mode;
const cached = cache[cacheKey];
const sharing = this.enableOptionSharing && defined(index);
if (cached) {
return cloneIfNotShared(cached, sharing);
}
const config = this.chart.config;
const scopeKeys = config.datasetElementScopeKeys(this._type, elementType);
const prefixes = active ? [
`${elementType}Hover`,
"hover",
elementType,
""
] : [
elementType,
""
];
const scopes = config.getOptionScopes(this.getDataset(), scopeKeys);
const names2 = Object.keys(defaults2.elements[elementType]);
const context = () => this.getContext(index, active, mode);
const values = config.resolveNamedOptions(scopes, names2, context, prefixes);
if (values.$shared) {
values.$shared = sharing;
cache[cacheKey] = Object.freeze(cloneIfNotShared(values, sharing));
}
return values;
}
_resolveAnimations(index, transition, active) {
const chart = this.chart;
const cache = this._cachedDataOpts;
const cacheKey = `animation-${transition}`;
const cached = cache[cacheKey];
if (cached) {
return cached;
}
let options;
if (chart.options.animation !== false) {
const config = this.chart.config;
const scopeKeys = config.datasetAnimationScopeKeys(this._type, transition);
const scopes = config.getOptionScopes(this.getDataset(), scopeKeys);
options = config.createResolver(scopes, this.getContext(index, active, transition));
}
const animations = new Animations(chart, options && options.animations);
if (options && options._cacheable) {
cache[cacheKey] = Object.freeze(animations);
}
return animations;
}
getSharedOptions(options) {
if (!options.$shared) {
return;
}
return this._sharedOptions || (this._sharedOptions = Object.assign({}, options));
}
includeOptions(mode, sharedOptions) {
return !sharedOptions || isDirectUpdateMode(mode) || this.chart._animationsDisabled;
}
_getSharedOptions(start, mode) {
const firstOpts = this.resolveDataElementOptions(start, mode);
const previouslySharedOptions = this._sharedOptions;
const sharedOptions = this.getSharedOptions(firstOpts);
const includeOptions = this.includeOptions(mode, sharedOptions) || sharedOptions !== previouslySharedOptions;
this.updateSharedOptions(sharedOptions, mode, firstOpts);
return {
sharedOptions,
includeOptions
};
}
updateElement(element, index, properties, mode) {
if (isDirectUpdateMode(mode)) {
Object.assign(element, properties);
} else {
this._resolveAnimations(index, mode).update(element, properties);
}
}
updateSharedOptions(sharedOptions, mode, newOptions) {
if (sharedOptions && !isDirectUpdateMode(mode)) {
this._resolveAnimations(void 0, mode).update(sharedOptions, newOptions);
}
}
_setStyle(element, index, mode, active) {
element.active = active;
const options = this.getStyle(index, active);
this._resolveAnimations(index, mode, active).update(element, {
options: !active && this.getSharedOptions(options) || options
});
}
removeHoverStyle(element, datasetIndex, index) {
this._setStyle(element, index, "active", false);
}
setHoverStyle(element, datasetIndex, index) {
this._setStyle(element, index, "active", true);
}
_removeDatasetHoverStyle() {
const element = this._cachedMeta.dataset;
if (element) {
this._setStyle(element, void 0, "active", false);
}
}
_setDatasetHoverStyle() {
const element = this._cachedMeta.dataset;
if (element) {
this._setStyle(element, void 0, "active", true);
}
}
_resyncElements(resetNewElements) {
const data = this._data;
const elements = this._cachedMeta.data;
for (const [method, arg1, arg2] of this._syncList) {
this[method](arg1, arg2);
}
this._syncList = [];
const numMeta = elements.length;
const numData = data.length;
const count = Math.min(numData, numMeta);
if (count) {
this.parse(0, count);
}
if (numData > numMeta) {
this._insertElements(numMeta, numData - numMeta, resetNewElements);
} else if (numData < numMeta) {
this._removeElements(numData, numMeta - numData);
}
}
_insertElements(start, count, resetNewElements = true) {
const meta = this._cachedMeta;
const data = meta.data;
const end = start + count;
let i2;
const move = (arr) => {
arr.length += count;
for (i2 = arr.length - 1; i2 >= end; i2--) {
arr[i2] = arr[i2 - count];
}
};
move(data);
for (i2 = start; i2 < end; ++i2) {
data[i2] = new this.dataElementType();
}
if (this._parsing) {
move(meta._parsed);
}
this.parse(start, count);
if (resetNewElements) {
this.updateElements(data, start, count, "reset");
}
}
updateElements(element, start, count, mode) {
}
_removeElements(start, count) {
const meta = this._cachedMeta;
if (this._parsing) {
const removed = meta._parsed.splice(start, count);
if (meta._stacked) {
clearStacks(meta, removed);
}
}
meta.data.splice(start, count);
}
_sync(args) {
if (this._parsing) {
this._syncList.push(args);
} else {
const [method, arg1, arg2] = args;
this[method](arg1, arg2);
}
this.chart._dataChanges.push([
this.index,
...args
]);
}
_onDataPush() {
const count = arguments.length;
this._sync([
"_insertElements",
this.getDataset().data.length - count,
count
]);
}
_onDataPop() {
this._sync([
"_removeElements",
this._cachedMeta.data.length - 1,
1
]);
}
_onDataShift() {
this._sync([
"_removeElements",
0,
1
]);
}
_onDataSplice(start, count) {
if (count) {
this._sync([
"_removeElements",
start,
count
]);
}
const newCount = arguments.length - 2;
if (newCount) {
this._sync([
"_insertElements",
start,
newCount
]);
}
}
_onDataUnshift() {
this._sync([
"_insertElements",
0,
arguments.length
]);
}
};
__publicField(DatasetController, "defaults", {});
__publicField(DatasetController, "datasetElementType", null);
__publicField(DatasetController, "dataElementType", null);
function getAllScaleValues(scale, type) {
if (!scale._cache.$bar) {
const visibleMetas = scale.getMatchingVisibleMetas(type);
let values = [];
for (let i2 = 0, ilen = visibleMetas.length; i2 < ilen; i2++) {
values = values.concat(visibleMetas[i2].controller.getAllParsedValues(scale));
}
scale._cache.$bar = _arrayUnique(values.sort((a2, b2) => a2 - b2));
}
return scale._cache.$bar;
}
function computeMinSampleSize(meta) {
const scale = meta.iScale;
const values = getAllScaleValues(scale, meta.type);
let min = scale._length;
let i2, ilen, curr, prev;
const updateMinAndPrev = () => {
if (curr === 32767 || curr === -32768) {
return;
}
if (defined(prev)) {
min = Math.min(min, Math.abs(curr - prev) || min);
}
prev = curr;
};
for (i2 = 0, ilen = values.length; i2 < ilen; ++i2) {
curr = scale.getPixelForValue(values[i2]);
updateMinAndPrev();
}
prev = void 0;
for (i2 = 0, ilen = scale.ticks.length; i2 < ilen; ++i2) {
curr = scale.getPixelForTick(i2);
updateMinAndPrev();
}
return min;
}
function computeFitCategoryTraits(index, ruler, options, stackCount) {
const thickness = options.barThickness;
let size, ratio;
if (isNullOrUndef(thickness)) {
size = ruler.min * options.categoryPercentage;
ratio = options.barPercentage;
} else {
size = thickness * stackCount;
ratio = 1;
}
return {
chunk: size / stackCount,
ratio,
start: ruler.pixels[index] - size / 2
};
}
function computeFlexCategoryTraits(index, ruler, options, stackCount) {
const pixels = ruler.pixels;
const curr = pixels[index];
let prev = index > 0 ? pixels[index - 1] : null;
let next = index < pixels.length - 1 ? pixels[index + 1] : null;
const percent = options.categoryPercentage;
if (prev === null) {
prev = curr - (next === null ? ruler.end - ruler.start : next - curr);
}
if (next === null) {
next = curr + curr - prev;
}
const start = curr - (curr - Math.min(prev, next)) / 2 * percent;
const size = Math.abs(next - prev) / 2 * percent;
return {
chunk: size / stackCount,
ratio: options.barPercentage,
start
};
}
function parseFloatBar(entry, item, vScale, i2) {
const startValue = vScale.parse(entry[0], i2);
const endValue = vScale.parse(entry[1], i2);
const min = Math.min(startValue, endValue);
const max = Math.max(startValue, endValue);
let barStart = min;
let barEnd = max;
if (Math.abs(min) > Math.abs(max)) {
barStart = max;
barEnd = min;
}
item[vScale.axis] = barEnd;
item._custom = {
barStart,
barEnd,
start: startValue,
end: endValue,
min,
max
};
}
function parseValue(entry, item, vScale, i2) {
if (isArray(entry)) {
parseFloatBar(entry, item, vScale, i2);
} else {
item[vScale.axis] = vScale.parse(entry, i2);
}
return item;
}
function parseArrayOrPrimitive(meta, data, start, count) {
const iScale = meta.iScale;
const vScale = meta.vScale;
const labels = iScale.getLabels();
const singleScale = iScale === vScale;
const parsed = [];
let i2, ilen, item, entry;
for (i2 = start, ilen = start + count; i2 < ilen; ++i2) {
entry = data[i2];
item = {};
item[iScale.axis] = singleScale || iScale.parse(labels[i2], i2);
parsed.push(parseValue(entry, item, vScale, i2));
}
return parsed;
}
function isFloatBar(custom) {
return custom && custom.barStart !== void 0 && custom.barEnd !== void 0;
}
function barSign(size, vScale, actualBase) {
if (size !== 0) {
return sign(size);
}
return (vScale.isHorizontal() ? 1 : -1) * (vScale.min >= actualBase ? 1 : -1);
}
function borderProps(properties) {
let reverse, start, end, top, bottom;
if (properties.horizontal) {
reverse = properties.base > properties.x;
start = "left";
end = "right";
} else {
reverse = properties.base < properties.y;
start = "bottom";
end = "top";
}
if (reverse) {
top = "end";
bottom = "start";
} else {
top = "start";
bottom = "end";
}
return {
start,
end,
reverse,
top,
bottom
};
}
function setBorderSkipped(properties, options, stack, index) {
let edge = options.borderSkipped;
const res = {};
if (!edge) {
properties.borderSkipped = res;
return;
}
if (edge === true) {
properties.borderSkipped = {
top: true,
right: true,
bottom: true,
left: true
};
return;
}
const { start, end, reverse, top, bottom } = borderProps(properties);
if (edge === "middle" && stack) {
properties.enableBorderRadius = true;
if ((stack._top || 0) === index) {
edge = top;
} else if ((stack._bottom || 0) === index) {
edge = bottom;
} else {
res[parseEdge(bottom, start, end, reverse)] = true;
edge = top;
}
}
res[parseEdge(edge, start, end, reverse)] = true;
properties.borderSkipped = res;
}
function parseEdge(edge, a2, b2, reverse) {
if (reverse) {
edge = swap(edge, a2, b2);
edge = startEnd(edge, b2, a2);
} else {
edge = startEnd(edge, a2, b2);
}
return edge;
}
function swap(orig, v1, v2) {
return orig === v1 ? v2 : orig === v2 ? v1 : orig;
}
function startEnd(v2, start, end) {
return v2 === "start" ? start : v2 === "end" ? end : v2;
}
function setInflateAmount(properties, { inflateAmount }, ratio) {
properties.inflateAmount = inflateAmount === "auto" ? ratio === 1 ? 0.33 : 0 : inflateAmount;
}
var BarController = class extends DatasetController {
parsePrimitiveData(meta, data, start, count) {
return parseArrayOrPrimitive(meta, data, start, count);
}
parseArrayData(meta, data, start, count) {
return parseArrayOrPrimitive(meta, data, start, count);
}
parseObjectData(meta, data, start, count) {
const { iScale, vScale } = meta;
const { xAxisKey = "x", yAxisKey = "y" } = this._parsing;
const iAxisKey = iScale.axis === "x" ? xAxisKey : yAxisKey;
const vAxisKey = vScale.axis === "x" ? xAxisKey : yAxisKey;
const parsed = [];
let i2, ilen, item, obj;
for (i2 = start, ilen = start + count; i2 < ilen; ++i2) {
obj = data[i2];
item = {};
item[iScale.axis] = iScale.parse(resolveObjectKey(obj, iAxisKey), i2);
parsed.push(parseValue(resolveObjectKey(obj, vAxisKey), item, vScale, i2));
}
return parsed;
}
updateRangeFromParsed(range, scale, parsed, stack) {
super.updateRangeFromParsed(range, scale, parsed, stack);
const custom = parsed._custom;
if (custom && scale === this._cachedMeta.vScale) {
range.min = Math.min(range.min, custom.min);
range.max = Math.max(range.max, custom.max);
}
}
getMaxOverflow() {
return 0;
}
getLabelAndValue(index) {
const meta = this._cachedMeta;
const { iScale, vScale } = meta;
const parsed = this.getParsed(index);
const custom = parsed._custom;
const value = isFloatBar(custom) ? "[" + custom.start + ", " + custom.end + "]" : "" + vScale.getLabelForValue(parsed[vScale.axis]);
return {
label: "" + iScale.getLabelForValue(parsed[iScale.axis]),
value
};
}
initialize() {
this.enableOptionSharing = true;
super.initialize();
const meta = this._cachedMeta;
meta.stack = this.getDataset().stack;
}
update(mode) {
const meta = this._cachedMeta;
this.updateElements(meta.data, 0, meta.data.length, mode);
}
updateElements(bars, start, count, mode) {
const reset2 = mode === "reset";
const { index, _cachedMeta: { vScale } } = this;
const base = vScale.getBasePixel();
const horizontal = vScale.isHorizontal();
const ruler = this._getRuler();
const { sharedOptions, includeOptions } = this._getSharedOptions(start, mode);
for (let i2 = start; i2 < start + count; i2++) {
const parsed = this.getParsed(i2);
const vpixels = reset2 || isNullOrUndef(parsed[vScale.axis]) ? {
base,
head: base
} : this._calculateBarValuePixels(i2);
const ipixels = this._calculateBarIndexPixels(i2, ruler);
const stack = (parsed._stacks || {})[vScale.axis];
const properties = {
horizontal,
base: vpixels.base,
enableBorderRadius: !stack || isFloatBar(parsed._custom) || index === stack._top || index === stack._bottom,
x: horizontal ? vpixels.head : ipixels.center,
y: horizontal ? ipixels.center : vpixels.head,
height: horizontal ? ipixels.size : Math.abs(vpixels.size),
width: horizontal ? Math.abs(vpixels.size) : ipixels.size
};
if (includeOptions) {
properties.options = sharedOptions || this.resolveDataElementOptions(i2, bars[i2].active ? "active" : mode);
}
const options = properties.options || bars[i2].options;
setBorderSkipped(properties, options, stack, index);
setInflateAmount(properties, options, ruler.ratio);
this.updateElement(bars[i2], i2, properties, mode);
}
}
_getStacks(last, dataIndex) {
const { iScale } = this._cachedMeta;
const metasets = iScale.getMatchingVisibleMetas(this._type).filter((meta) => meta.controller.options.grouped);
const stacked = iScale.options.stacked;
const stacks = [];
const currentParsed = this._cachedMeta.controller.getParsed(dataIndex);
const iScaleValue = currentParsed && currentParsed[iScale.axis];
const skipNull = (meta) => {
const parsed = meta._parsed.find((item) => item[iScale.axis] === iScaleValue);
const val = parsed && parsed[meta.vScale.axis];
if (isNullOrUndef(val) || isNaN(val)) {
return true;
}
};
for (const meta of metasets) {
if (dataIndex !== void 0 && skipNull(meta)) {
continue;
}
if (stacked === false || stacks.indexOf(meta.stack) === -1 || stacked === void 0 && meta.stack === void 0) {
stacks.push(meta.stack);
}
if (meta.index === last) {
break;
}
}
if (!stacks.length) {
stacks.push(void 0);
}
return stacks;
}
_getStackCount(index) {
return this._getStacks(void 0, index).length;
}
_getStackIndex(datasetIndex, name, dataIndex) {
const stacks = this._getStacks(datasetIndex, dataIndex);
const index = name !== void 0 ? stacks.indexOf(name) : -1;
return index === -1 ? stacks.length - 1 : index;
}
_getRuler() {
const opts = this.options;
const meta = this._cachedMeta;
const iScale = meta.iScale;
const pixels = [];
let i2, ilen;
for (i2 = 0, ilen = meta.data.length; i2 < ilen; ++i2) {
pixels.push(iScale.getPixelForValue(this.getParsed(i2)[iScale.axis], i2));
}
const barThickness = opts.barThickness;
const min = barThickness || computeMinSampleSize(meta);
return {
min,
pixels,
start: iScale._startPixel,
end: iScale._endPixel,
stackCount: this._getStackCount(),
scale: iScale,
grouped: opts.grouped,
ratio: barThickness ? 1 : opts.categoryPercentage * opts.barPercentage
};
}
_calculateBarValuePixels(index) {
const { _cachedMeta: { vScale, _stacked, index: datasetIndex }, options: { base: baseValue, minBarLength } } = this;
const actualBase = baseValue || 0;
const parsed = this.getParsed(index);
const custom = parsed._custom;
const floating = isFloatBar(custom);
let value = parsed[vScale.axis];
let start = 0;
let length = _stacked ? this.applyStack(vScale, parsed, _stacked) : value;
let head, size;
if (length !== value) {
start = length - value;
length = value;
}
if (floating) {
value = custom.barStart;
length = custom.barEnd - custom.barStart;
if (value !== 0 && sign(value) !== sign(custom.barEnd)) {
start = 0;
}
start += value;
}
const startValue = !isNullOrUndef(baseValue) && !floating ? baseValue : start;
let base = vScale.getPixelForValue(startValue);
if (this.chart.getDataVisibility(index)) {
head = vScale.getPixelForValue(start + length);
} else {
head = base;
}
size = head - base;
if (Math.abs(size) < minBarLength) {
size = barSign(size, vScale, actualBase) * minBarLength;
if (value === actualBase) {
base -= size / 2;
}
const startPixel = vScale.getPixelForDecimal(0);
const endPixel = vScale.getPixelForDecimal(1);
const min = Math.min(startPixel, endPixel);
const max = Math.max(startPixel, endPixel);
base = Math.max(Math.min(base, max), min);
head = base + size;
if (_stacked && !floating) {
parsed._stacks[vScale.axis]._visualValues[datasetIndex] = vScale.getValueForPixel(head) - vScale.getValueForPixel(base);
}
}
if (base === vScale.getPixelForValue(actualBase)) {
const halfGrid = sign(size) * vScale.getLineWidthForValue(actualBase) / 2;
base += halfGrid;
size -= halfGrid;
}
return {
size,
base,
head,
center: head + size / 2
};
}
_calculateBarIndexPixels(index, ruler) {
const scale = ruler.scale;
const options = this.options;
const skipNull = options.skipNull;
const maxBarThickness = valueOrDefault(options.maxBarThickness, Infinity);
let center, size;
if (ruler.grouped) {
const stackCount = skipNull ? this._getStackCount(index) : ruler.stackCount;
const range = options.barThickness === "flex" ? computeFlexCategoryTraits(index, ruler, options, stackCount) : computeFitCategoryTraits(index, ruler, options, stackCount);
const stackIndex = this._getStackIndex(this.index, this._cachedMeta.stack, skipNull ? index : void 0);
center = range.start + range.chunk * stackIndex + range.chunk / 2;
size = Math.min(maxBarThickness, range.chunk * range.ratio);
} else {
center = scale.getPixelForValue(this.getParsed(index)[scale.axis], index);
size = Math.min(maxBarThickness, ruler.min * ruler.ratio);
}
return {
base: center - size / 2,
head: center + size / 2,
center,
size
};
}
draw() {
const meta = this._cachedMeta;
const vScale = meta.vScale;
const rects = meta.data;
const ilen = rects.length;
let i2 = 0;
for (; i2 < ilen; ++i2) {
if (this.getParsed(i2)[vScale.axis] !== null && !rects[i2].hidden) {
rects[i2].draw(this._ctx);
}
}
}
};
__publicField(BarController, "id", "bar");
__publicField(BarController, "defaults", {
datasetElementType: false,
dataElementType: "bar",
categoryPercentage: 0.8,
barPercentage: 0.9,
grouped: true,
animations: {
numbers: {
type: "number",
properties: [
"x",
"y",
"base",
"width",
"height"
]
}
}
});
__publicField(BarController, "overrides", {
scales: {
_index_: {
type: "category",
offset: true,
grid: {
offset: true
}
},
_value_: {
type: "linear",
beginAtZero: true
}
}
});
function getRatioAndOffset(rotation, circumference, cutout) {
let ratioX = 1;
let ratioY = 1;
let offsetX = 0;
let offsetY = 0;
if (circumference < TAU) {
const startAngle = rotation;
const endAngle = startAngle + circumference;
const startX = Math.cos(startAngle);
const startY = Math.sin(startAngle);
const endX = Math.cos(endAngle);
const endY = Math.sin(endAngle);
const calcMax = (angle, a2, b2) => _angleBetween(angle, startAngle, endAngle, true) ? 1 : Math.max(a2, a2 * cutout, b2, b2 * cutout);
const calcMin = (angle, a2, b2) => _angleBetween(angle, startAngle, endAngle, true) ? -1 : Math.min(a2, a2 * cutout, b2, b2 * cutout);
const maxX = calcMax(0, startX, endX);
const maxY = calcMax(HALF_PI, startY, endY);
const minX = calcMin(PI, startX, endX);
const minY = calcMin(PI + HALF_PI, startY, endY);
ratioX = (maxX - minX) / 2;
ratioY = (maxY - minY) / 2;
offsetX = -(maxX + minX) / 2;
offsetY = -(maxY + minY) / 2;
}
return {
ratioX,
ratioY,
offsetX,
offsetY
};
}
var DoughnutController = class extends DatasetController {
constructor(chart, datasetIndex) {
super(chart, datasetIndex);
this.enableOptionSharing = true;
this.innerRadius = void 0;
this.outerRadius = void 0;
this.offsetX = void 0;
this.offsetY = void 0;
}
linkScales() {
}
parse(start, count) {
const data = this.getDataset().data;
const meta = this._cachedMeta;
if (this._parsing === false) {
meta._parsed = data;
} else {
let getter = (i3) => +data[i3];
if (isObject(data[start])) {
const { key = "value" } = this._parsing;
getter = (i3) => +resolveObjectKey(data[i3], key);
}
let i2, ilen;
for (i2 = start, ilen = start + count; i2 < ilen; ++i2) {
meta._parsed[i2] = getter(i2);
}
}
}
_getRotation() {
return toRadians(this.options.rotation - 90);
}
_getCircumference() {
return toRadians(this.options.circumference);
}
_getRotationExtents() {
let min = TAU;
let max = -TAU;
for (let i2 = 0; i2 < this.chart.data.datasets.length; ++i2) {
if (this.chart.isDatasetVisible(i2) && this.chart.getDatasetMeta(i2).type === this._type) {
const controller = this.chart.getDatasetMeta(i2).controller;
const rotation = controller._getRotation();
const circumference = controller._getCircumference();
min = Math.min(min, rotation);
max = Math.max(max, rotation + circumference);
}
}
return {
rotation: min,
circumference: max - min
};
}
update(mode) {
const chart = this.chart;
const { chartArea } = chart;
const meta = this._cachedMeta;
const arcs = meta.data;
const spacing = this.getMaxBorderWidth() + this.getMaxOffset(arcs) + this.options.spacing;
const maxSize = Math.max((Math.min(chartArea.width, chartArea.height) - spacing) / 2, 0);
const cutout = Math.min(toPercentage(this.options.cutout, maxSize), 1);
const chartWeight = this._getRingWeight(this.index);
const { circumference, rotation } = this._getRotationExtents();
const { ratioX, ratioY, offsetX, offsetY } = getRatioAndOffset(rotation, circumference, cutout);
const maxWidth = (chartArea.width - spacing) / ratioX;
const maxHeight = (chartArea.height - spacing) / ratioY;
const maxRadius = Math.max(Math.min(maxWidth, maxHeight) / 2, 0);
const outerRadius = toDimension(this.options.radius, maxRadius);
const innerRadius = Math.max(outerRadius * cutout, 0);
const radiusLength = (outerRadius - innerRadius) / this._getVisibleDatasetWeightTotal();
this.offsetX = offsetX * outerRadius;
this.offsetY = offsetY * outerRadius;
meta.total = this.calculateTotal();
this.outerRadius = outerRadius - radiusLength * this._getRingWeightOffset(this.index);
this.innerRadius = Math.max(this.outerRadius - radiusLength * chartWeight, 0);
this.updateElements(arcs, 0, arcs.length, mode);
}
_circumference(i2, reset2) {
const opts = this.options;
const meta = this._cachedMeta;
const circumference = this._getCircumference();
if (reset2 && opts.animation.animateRotate || !this.chart.getDataVisibility(i2) || meta._parsed[i2] === null || meta.data[i2].hidden) {
return 0;
}
return this.calculateCircumference(meta._parsed[i2] * circumference / TAU);
}
updateElements(arcs, start, count, mode) {
const reset2 = mode === "reset";
const chart = this.chart;
const chartArea = chart.chartArea;
const opts = chart.options;
const animationOpts = opts.animation;
const centerX = (chartArea.left + chartArea.right) / 2;
const centerY = (chartArea.top + chartArea.bottom) / 2;
const animateScale = reset2 && animationOpts.animateScale;
const innerRadius = animateScale ? 0 : this.innerRadius;
const outerRadius = animateScale ? 0 : this.outerRadius;
const { sharedOptions, includeOptions } = this._getSharedOptions(start, mode);
let startAngle = this._getRotation();
let i2;
for (i2 = 0; i2 < start; ++i2) {
startAngle += this._circumference(i2, reset2);
}
for (i2 = start; i2 < start + count; ++i2) {
const circumference = this._circumference(i2, reset2);
const arc = arcs[i2];
const properties = {
x: centerX + this.offsetX,
y: centerY + this.offsetY,
startAngle,
endAngle: startAngle + circumference,
circumference,
outerRadius,
innerRadius
};
if (includeOptions) {
properties.options = sharedOptions || this.resolveDataElementOptions(i2, arc.active ? "active" : mode);
}
startAngle += circumference;
this.updateElement(arc, i2, properties, mode);
}
}
calculateTotal() {
const meta = this._cachedMeta;
const metaData = meta.data;
let total = 0;
let i2;
for (i2 = 0; i2 < metaData.length; i2++) {
const value = meta._parsed[i2];
if (value !== null && !isNaN(value) && this.chart.getDataVisibility(i2) && !metaData[i2].hidden) {
total += Math.abs(value);
}
}
return total;
}
calculateCircumference(value) {
const total = this._cachedMeta.total;
if (total > 0 && !isNaN(value)) {
return TAU * (Math.abs(value) / total);
}
return 0;
}
getLabelAndValue(index) {
const meta = this._cachedMeta;
const chart = this.chart;
const labels = chart.data.labels || [];
const value = formatNumber(meta._parsed[index], chart.options.locale);
return {
label: labels[index] || "",
value
};
}
getMaxBorderWidth(arcs) {
let max = 0;
const chart = this.chart;
let i2, ilen, meta, controller, options;
if (!arcs) {
for (i2 = 0, ilen = chart.data.datasets.length; i2 < ilen; ++i2) {
if (chart.isDatasetVisible(i2)) {
meta = chart.getDatasetMeta(i2);
arcs = meta.data;
controller = meta.controller;
break;
}
}
}
if (!arcs) {
return 0;
}
for (i2 = 0, ilen = arcs.length; i2 < ilen; ++i2) {
options = controller.resolveDataElementOptions(i2);
if (options.borderAlign !== "inner") {
max = Math.max(max, options.borderWidth || 0, options.hoverBorderWidth || 0);
}
}
return max;
}
getMaxOffset(arcs) {
let max = 0;
for (let i2 = 0, ilen = arcs.length; i2 < ilen; ++i2) {
const options = this.resolveDataElementOptions(i2);
max = Math.max(max, options.offset || 0, options.hoverOffset || 0);
}
return max;
}
_getRingWeightOffset(datasetIndex) {
let ringWeightOffset = 0;
for (let i2 = 0; i2 < datasetIndex; ++i2) {
if (this.chart.isDatasetVisible(i2)) {
ringWeightOffset += this._getRingWeight(i2);
}
}
return ringWeightOffset;
}
_getRingWeight(datasetIndex) {
return Math.max(valueOrDefault(this.chart.data.datasets[datasetIndex].weight, 1), 0);
}
_getVisibleDatasetWeightTotal() {
return this._getRingWeightOffset(this.chart.data.datasets.length) || 1;
}
};
__publicField(DoughnutController, "id", "doughnut");
__publicField(DoughnutController, "defaults", {
datasetElementType: false,
dataElementType: "arc",
animation: {
animateRotate: true,
animateScale: false
},
animations: {
numbers: {
type: "number",
properties: [
"circumference",
"endAngle",
"innerRadius",
"outerRadius",
"startAngle",
"x",
"y",
"offset",
"borderWidth",
"spacing"
]
}
},
cutout: "50%",
rotation: 0,
circumference: 360,
radius: "100%",
spacing: 0,
indexAxis: "r"
});
__publicField(DoughnutController, "descriptors", {
_scriptable: (name) => name !== "spacing",
_indexable: (name) => name !== "spacing" && !name.startsWith("borderDash") && !name.startsWith("hoverBorderDash")
});
__publicField(DoughnutController, "overrides", {
aspectRatio: 1,
plugins: {
legend: {
labels: {
generateLabels(chart) {
const data = chart.data;
if (data.labels.length && data.datasets.length) {
const { labels: { pointStyle, color: color2 } } = chart.legend.options;
return data.labels.map((label, i2) => {
const meta = chart.getDatasetMeta(0);
const style = meta.controller.getStyle(i2);
return {
text: label,
fillStyle: style.backgroundColor,
strokeStyle: style.borderColor,
fontColor: color2,
lineWidth: style.borderWidth,
pointStyle,
hidden: !chart.getDataVisibility(i2),
index: i2
};
});
}
return [];
}
},
onClick(e2, legendItem, legend) {
legend.chart.toggleDataVisibility(legendItem.index);
legend.chart.update();
}
}
}
});
var PieController = class extends DoughnutController {
};
__publicField(PieController, "id", "pie");
__publicField(PieController, "defaults", {
cutout: 0,
rotation: 0,
circumference: 360,
radius: "100%"
});
function abstract() {
throw new Error("This method is not implemented: Check that a complete date adapter is provided.");
}
var DateAdapterBase = class _DateAdapterBase {
constructor(options) {
__publicField(this, "options");
this.options = options || {};
}
/**
* Override default date adapter methods.
* Accepts type parameter to define options type.
* @example
* Chart._adapters._date.override<{myAdapterOption: string}>({
* init() {
* console.log(this.options.myAdapterOption);
* }
* })
*/
static override(members) {
Object.assign(_DateAdapterBase.prototype, members);
}
// eslint-disable-next-line @typescript-eslint/no-empty-function
init() {
}
formats() {
return abstract();
}
parse() {
return abstract();
}
format() {
return abstract();
}
add() {
return abstract();
}
diff() {
return abstract();
}
startOf() {
return abstract();
}
endOf() {
return abstract();
}
};
var adapters = {
_date: DateAdapterBase
};
function binarySearch(metaset, axis, value, intersect) {
const { controller, data, _sorted } = metaset;
const iScale = controller._cachedMeta.iScale;
if (iScale && axis === iScale.axis && axis !== "r" && _sorted && data.length) {
const lookupMethod = iScale._reversePixels ? _rlookupByKey : _lookupByKey;
if (!intersect) {
return lookupMethod(data, axis, value);
} else if (controller._sharedOptions) {
const el = data[0];
const range = typeof el.getRange === "function" && el.getRange(axis);
if (range) {
const start = lookupMethod(data, axis, value - range);
const end = lookupMethod(data, axis, value + range);
return {
lo: start.lo,
hi: end.hi
};
}
}
}
return {
lo: 0,
hi: data.length - 1
};
}
function evaluateInteractionItems(chart, axis, position, handler, intersect) {
const metasets = chart.getSortedVisibleDatasetMetas();
const value = position[axis];
for (let i2 = 0, ilen = metasets.length; i2 < ilen; ++i2) {
const { index, data } = metasets[i2];
const { lo, hi } = binarySearch(metasets[i2], axis, value, intersect);
for (let j2 = lo; j2 <= hi; ++j2) {
const element = data[j2];
if (!element.skip) {
handler(element, index, j2);
}
}
}
}
function getDistanceMetricForAxis(axis) {
const useX = axis.indexOf("x") !== -1;
const useY = axis.indexOf("y") !== -1;
return function(pt1, pt2) {
const deltaX = useX ? Math.abs(pt1.x - pt2.x) : 0;
const deltaY = useY ? Math.abs(pt1.y - pt2.y) : 0;
return Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaY, 2));
};
}
function getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) {
const items = [];
if (!includeInvisible && !chart.isPointInArea(position)) {
return items;
}
const evaluationFunc = function(element, datasetIndex, index) {
if (!includeInvisible && !_isPointInArea(element, chart.chartArea, 0)) {
return;
}
if (element.inRange(position.x, position.y, useFinalPosition)) {
items.push({
element,
datasetIndex,
index
});
}
};
evaluateInteractionItems(chart, axis, position, evaluationFunc, true);
return items;
}
function getNearestRadialItems(chart, position, axis, useFinalPosition) {
let items = [];
function evaluationFunc(element, datasetIndex, index) {
const { startAngle, endAngle } = element.getProps([
"startAngle",
"endAngle"
], useFinalPosition);
const { angle } = getAngleFromPoint(element, {
x: position.x,
y: position.y
});
if (_angleBetween(angle, startAngle, endAngle)) {
items.push({
element,
datasetIndex,
index
});
}
}
evaluateInteractionItems(chart, axis, position, evaluationFunc);
return items;
}
function getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition, includeInvisible) {
let items = [];
const distanceMetric = getDistanceMetricForAxis(axis);
let minDistance = Number.POSITIVE_INFINITY;
function evaluationFunc(element, datasetIndex, index) {
const inRange2 = element.inRange(position.x, position.y, useFinalPosition);
if (intersect && !inRange2) {
return;
}
const center = element.getCenterPoint(useFinalPosition);
const pointInArea = !!includeInvisible || chart.isPointInArea(center);
if (!pointInArea && !inRange2) {
return;
}
const distance = distanceMetric(position, center);
if (distance < minDistance) {
items = [
{
element,
datasetIndex,
index
}
];
minDistance = distance;
} else if (distance === minDistance) {
items.push({
element,
datasetIndex,
index
});
}
}
evaluateInteractionItems(chart, axis, position, evaluationFunc);
return items;
}
function getNearestItems(chart, position, axis, intersect, useFinalPosition, includeInvisible) {
if (!includeInvisible && !chart.isPointInArea(position)) {
return [];
}
return axis === "r" && !intersect ? getNearestRadialItems(chart, position, axis, useFinalPosition) : getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition, includeInvisible);
}
function getAxisItems(chart, position, axis, intersect, useFinalPosition) {
const items = [];
const rangeMethod = axis === "x" ? "inXRange" : "inYRange";
let intersectsItem = false;
evaluateInteractionItems(chart, axis, position, (element, datasetIndex, index) => {
if (element[rangeMethod] && element[rangeMethod](position[axis], useFinalPosition)) {
items.push({
element,
datasetIndex,
index
});
intersectsItem = intersectsItem || element.inRange(position.x, position.y, useFinalPosition);
}
});
if (intersect && !intersectsItem) {
return [];
}
return items;
}
var Interaction = {
evaluateInteractionItems,
modes: {
index(chart, e2, options, useFinalPosition) {
const position = getRelativePosition(e2, chart);
const axis = options.axis || "x";
const includeInvisible = options.includeInvisible || false;
const items = options.intersect ? getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) : getNearestItems(chart, position, axis, false, useFinalPosition, includeInvisible);
const elements = [];
if (!items.length) {
return [];
}
chart.getSortedVisibleDatasetMetas().forEach((meta) => {
const index = items[0].index;
const element = meta.data[index];
if (element && !element.skip) {
elements.push({
element,
datasetIndex: meta.index,
index
});
}
});
return elements;
},
dataset(chart, e2, options, useFinalPosition) {
const position = getRelativePosition(e2, chart);
const axis = options.axis || "xy";
const includeInvisible = options.includeInvisible || false;
let items = options.intersect ? getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) : getNearestItems(chart, position, axis, false, useFinalPosition, includeInvisible);
if (items.length > 0) {
const datasetIndex = items[0].datasetIndex;
const data = chart.getDatasetMeta(datasetIndex).data;
items = [];
for (let i2 = 0; i2 < data.length; ++i2) {
items.push({
element: data[i2],
datasetIndex,
index: i2
});
}
}
return items;
},
point(chart, e2, options, useFinalPosition) {
const position = getRelativePosition(e2, chart);
const axis = options.axis || "xy";
const includeInvisible = options.includeInvisible || false;
return getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible);
},
nearest(chart, e2, options, useFinalPosition) {
const position = getRelativePosition(e2, chart);
const axis = options.axis || "xy";
const includeInvisible = options.includeInvisible || false;
return getNearestItems(chart, position, axis, options.intersect, useFinalPosition, includeInvisible);
},
x(chart, e2, options, useFinalPosition) {
const position = getRelativePosition(e2, chart);
return getAxisItems(chart, position, "x", options.intersect, useFinalPosition);
},
y(chart, e2, options, useFinalPosition) {
const position = getRelativePosition(e2, chart);
return getAxisItems(chart, position, "y", options.intersect, useFinalPosition);
}
}
};
var STATIC_POSITIONS = [
"left",
"top",
"right",
"bottom"
];
function filterByPosition(array, position) {
return array.filter((v2) => v2.pos === position);
}
function filterDynamicPositionByAxis(array, axis) {
return array.filter((v2) => STATIC_POSITIONS.indexOf(v2.pos) === -1 && v2.box.axis === axis);
}
function sortByWeight(array, reverse) {
return array.sort((a2, b2) => {
const v0 = reverse ? b2 : a2;
const v1 = reverse ? a2 : b2;
return v0.weight === v1.weight ? v0.index - v1.index : v0.weight - v1.weight;
});
}
function wrapBoxes(boxes) {
const layoutBoxes = [];
let i2, ilen, box, pos, stack, stackWeight;
for (i2 = 0, ilen = (boxes || []).length; i2 < ilen; ++i2) {
box = boxes[i2];
({ position: pos, options: { stack, stackWeight = 1 } } = box);
layoutBoxes.push({
index: i2,
box,
pos,
horizontal: box.isHorizontal(),
weight: box.weight,
stack: stack && pos + stack,
stackWeight
});
}
return layoutBoxes;
}
function buildStacks(layouts2) {
const stacks = {};
for (const wrap of layouts2) {
const { stack, pos, stackWeight } = wrap;
if (!stack || !STATIC_POSITIONS.includes(pos)) {
continue;
}
const _stack = stacks[stack] || (stacks[stack] = {
count: 0,
placed: 0,
weight: 0,
size: 0
});
_stack.count++;
_stack.weight += stackWeight;
}
return stacks;
}
function setLayoutDims(layouts2, params) {
const stacks = buildStacks(layouts2);
const { vBoxMaxWidth, hBoxMaxHeight } = params;
let i2, ilen, layout;
for (i2 = 0, ilen = layouts2.length; i2 < ilen; ++i2) {
layout = layouts2[i2];
const { fullSize } = layout.box;
const stack = stacks[layout.stack];
const factor = stack && layout.stackWeight / stack.weight;
if (layout.horizontal) {
layout.width = factor ? factor * vBoxMaxWidth : fullSize && params.availableWidth;
layout.height = hBoxMaxHeight;
} else {
layout.width = vBoxMaxWidth;
layout.height = factor ? factor * hBoxMaxHeight : fullSize && params.availableHeight;
}
}
return stacks;
}
function buildLayoutBoxes(boxes) {
const layoutBoxes = wrapBoxes(boxes);
const fullSize = sortByWeight(layoutBoxes.filter((wrap) => wrap.box.fullSize), true);
const left = sortByWeight(filterByPosition(layoutBoxes, "left"), true);
const right = sortByWeight(filterByPosition(layoutBoxes, "right"));
const top = sortByWeight(filterByPosition(layoutBoxes, "top"), true);
const bottom = sortByWeight(filterByPosition(layoutBoxes, "bottom"));
const centerHorizontal = filterDynamicPositionByAxis(layoutBoxes, "x");
const centerVertical = filterDynamicPositionByAxis(layoutBoxes, "y");
return {
fullSize,
leftAndTop: left.concat(top),
rightAndBottom: right.concat(centerVertical).concat(bottom).concat(centerHorizontal),
chartArea: filterByPosition(layoutBoxes, "chartArea"),
vertical: left.concat(right).concat(centerVertical),
horizontal: top.concat(bottom).concat(centerHorizontal)
};
}
function getCombinedMax(maxPadding, chartArea, a2, b2) {
return Math.max(maxPadding[a2], chartArea[a2]) + Math.max(maxPadding[b2], chartArea[b2]);
}
function updateMaxPadding(maxPadding, boxPadding) {
maxPadding.top = Math.max(maxPadding.top, boxPadding.top);
maxPadding.left = Math.max(maxPadding.left, boxPadding.left);
maxPadding.bottom = Math.max(maxPadding.bottom, boxPadding.bottom);
maxPadding.right = Math.max(maxPadding.right, boxPadding.right);
}
function updateDims(chartArea, params, layout, stacks) {
const { pos, box } = layout;
const maxPadding = chartArea.maxPadding;
if (!isObject(pos)) {
if (layout.size) {
chartArea[pos] -= layout.size;
}
const stack = stacks[layout.stack] || {
size: 0,
count: 1
};
stack.size = Math.max(stack.size, layout.horizontal ? box.height : box.width);
layout.size = stack.size / stack.count;
chartArea[pos] += layout.size;
}
if (box.getPadding) {
updateMaxPadding(maxPadding, box.getPadding());
}
const newWidth = Math.max(0, params.outerWidth - getCombinedMax(maxPadding, chartArea, "left", "right"));
const newHeight = Math.max(0, params.outerHeight - getCombinedMax(maxPadding, chartArea, "top", "bottom"));
const widthChanged = newWidth !== chartArea.w;
const heightChanged = newHeight !== chartArea.h;
chartArea.w = newWidth;
chartArea.h = newHeight;
return layout.horizontal ? {
same: widthChanged,
other: heightChanged
} : {
same: heightChanged,
other: widthChanged
};
}
function handleMaxPadding(chartArea) {
const maxPadding = chartArea.maxPadding;
function updatePos(pos) {
const change = Math.max(maxPadding[pos] - chartArea[pos], 0);
chartArea[pos] += change;
return change;
}
chartArea.y += updatePos("top");
chartArea.x += updatePos("left");
updatePos("right");
updatePos("bottom");
}
function getMargins(horizontal, chartArea) {
const maxPadding = chartArea.maxPadding;
function marginForPositions(positions2) {
const margin = {
left: 0,
top: 0,
right: 0,
bottom: 0
};
positions2.forEach((pos) => {
margin[pos] = Math.max(chartArea[pos], maxPadding[pos]);
});
return margin;
}
return horizontal ? marginForPositions([
"left",
"right"
]) : marginForPositions([
"top",
"bottom"
]);
}
function fitBoxes(boxes, chartArea, params, stacks) {
const refitBoxes = [];
let i2, ilen, layout, box, refit, changed;
for (i2 = 0, ilen = boxes.length, refit = 0; i2 < ilen; ++i2) {
layout = boxes[i2];
box = layout.box;
box.update(layout.width || chartArea.w, layout.height || chartArea.h, getMargins(layout.horizontal, chartArea));
const { same, other } = updateDims(chartArea, params, layout, stacks);
refit |= same && refitBoxes.length;
changed = changed || other;
if (!box.fullSize) {
refitBoxes.push(layout);
}
}
return refit && fitBoxes(refitBoxes, chartArea, params, stacks) || changed;
}
function setBoxDims(box, left, top, width, height) {
box.top = top;
box.left = left;
box.right = left + width;
box.bottom = top + height;
box.width = width;
box.height = height;
}
function placeBoxes(boxes, chartArea, params, stacks) {
const userPadding = params.padding;
let { x: x2, y: y2 } = chartArea;
for (const layout of boxes) {
const box = layout.box;
const stack = stacks[layout.stack] || {
count: 1,
placed: 0,
weight: 1
};
const weight = layout.stackWeight / stack.weight || 1;
if (layout.horizontal) {
const width = chartArea.w * weight;
const height = stack.size || box.height;
if (defined(stack.start)) {
y2 = stack.start;
}
if (box.fullSize) {
setBoxDims(box, userPadding.left, y2, params.outerWidth - userPadding.right - userPadding.left, height);
} else {
setBoxDims(box, chartArea.left + stack.placed, y2, width, height);
}
stack.start = y2;
stack.placed += width;
y2 = box.bottom;
} else {
const height = chartArea.h * weight;
const width = stack.size || box.width;
if (defined(stack.start)) {
x2 = stack.start;
}
if (box.fullSize) {
setBoxDims(box, x2, userPadding.top, width, params.outerHeight - userPadding.bottom - userPadding.top);
} else {
setBoxDims(box, x2, chartArea.top + stack.placed, width, height);
}
stack.start = x2;
stack.placed += height;
x2 = box.right;
}
}
chartArea.x = x2;
chartArea.y = y2;
}
var layouts = {
addBox(chart, item) {
if (!chart.boxes) {
chart.boxes = [];
}
item.fullSize = item.fullSize || false;
item.position = item.position || "top";
item.weight = item.weight || 0;
item._layers = item._layers || function() {
return [
{
z: 0,
draw(chartArea) {
item.draw(chartArea);
}
}
];
};
chart.boxes.push(item);
},
removeBox(chart, layoutItem) {
const index = chart.boxes ? chart.boxes.indexOf(layoutItem) : -1;
if (index !== -1) {
chart.boxes.splice(index, 1);
}
},
configure(chart, item, options) {
item.fullSize = options.fullSize;
item.position = options.position;
item.weight = options.weight;
},
update(chart, width, height, minPadding) {
if (!chart) {
return;
}
const padding = toPadding(chart.options.layout.padding);
const availableWidth = Math.max(width - padding.width, 0);
const availableHeight = Math.max(height - padding.height, 0);
const boxes = buildLayoutBoxes(chart.boxes);
const verticalBoxes = boxes.vertical;
const horizontalBoxes = boxes.horizontal;
each(chart.boxes, (box) => {
if (typeof box.beforeLayout === "function") {
box.beforeLayout();
}
});
const visibleVerticalBoxCount = verticalBoxes.reduce((total, wrap) => wrap.box.options && wrap.box.options.display === false ? total : total + 1, 0) || 1;
const params = Object.freeze({
outerWidth: width,
outerHeight: height,
padding,
availableWidth,
availableHeight,
vBoxMaxWidth: availableWidth / 2 / visibleVerticalBoxCount,
hBoxMaxHeight: availableHeight / 2
});
const maxPadding = Object.assign({}, padding);
updateMaxPadding(maxPadding, toPadding(minPadding));
const chartArea = Object.assign({
maxPadding,
w: availableWidth,
h: availableHeight,
x: padding.left,
y: padding.top
}, padding);
const stacks = setLayoutDims(verticalBoxes.concat(horizontalBoxes), params);
fitBoxes(boxes.fullSize, chartArea, params, stacks);
fitBoxes(verticalBoxes, chartArea, params, stacks);
if (fitBoxes(horizontalBoxes, chartArea, params, stacks)) {
fitBoxes(verticalBoxes, chartArea, params, stacks);
}
handleMaxPadding(chartArea);
placeBoxes(boxes.leftAndTop, chartArea, params, stacks);
chartArea.x += chartArea.w;
chartArea.y += chartArea.h;
placeBoxes(boxes.rightAndBottom, chartArea, params, stacks);
chart.chartArea = {
left: chartArea.left,
top: chartArea.top,
right: chartArea.left + chartArea.w,
bottom: chartArea.top + chartArea.h,
height: chartArea.h,
width: chartArea.w
};
each(boxes.chartArea, (layout) => {
const box = layout.box;
Object.assign(box, chart.chartArea);
box.update(chartArea.w, chartArea.h, {
left: 0,
top: 0,
right: 0,
bottom: 0
});
});
}
};
var BasePlatform = class {
acquireContext(canvas, aspectRatio) {
}
releaseContext(context) {
return false;
}
addEventListener(chart, type, listener) {
}
removeEventListener(chart, type, listener) {
}
getDevicePixelRatio() {
return 1;
}
getMaximumSize(element, width, height, aspectRatio) {
width = Math.max(0, width || element.width);
height = height || element.height;
return {
width,
height: Math.max(0, aspectRatio ? Math.floor(width / aspectRatio) : height)
};
}
isAttached(canvas) {
return true;
}
updateConfig(config) {
}
};
var BasicPlatform = class extends BasePlatform {
acquireContext(item) {
return item && item.getContext && item.getContext("2d") || null;
}
updateConfig(config) {
config.options.animation = false;
}
};
var EXPANDO_KEY = "$chartjs";
var EVENT_TYPES = {
touchstart: "mousedown",
touchmove: "mousemove",
touchend: "mouseup",
pointerenter: "mouseenter",
pointerdown: "mousedown",
pointermove: "mousemove",
pointerup: "mouseup",
pointerleave: "mouseout",
pointerout: "mouseout"
};
var isNullOrEmpty = (value) => value === null || value === "";
function initCanvas(canvas, aspectRatio) {
const style = canvas.style;
const renderHeight = canvas.getAttribute("height");
const renderWidth = canvas.getAttribute("width");
canvas[EXPANDO_KEY] = {
initial: {
height: renderHeight,
width: renderWidth,
style: {
display: style.display,
height: style.height,
width: style.width
}
}
};
style.display = style.display || "block";
style.boxSizing = style.boxSizing || "border-box";
if (isNullOrEmpty(renderWidth)) {
const displayWidth = readUsedSize(canvas, "width");
if (displayWidth !== void 0) {
canvas.width = displayWidth;
}
}
if (isNullOrEmpty(renderHeight)) {
if (canvas.style.height === "") {
canvas.height = canvas.width / (aspectRatio || 2);
} else {
const displayHeight = readUsedSize(canvas, "height");
if (displayHeight !== void 0) {
canvas.height = displayHeight;
}
}
}
return canvas;
}
var eventListenerOptions = supportsEventListenerOptions ? {
passive: true
} : false;
function addListener(node, type, listener) {
if (node) {
node.addEventListener(type, listener, eventListenerOptions);
}
}
function removeListener(chart, type, listener) {
if (chart && chart.canvas) {
chart.canvas.removeEventListener(type, listener, eventListenerOptions);
}
}
function fromNativeEvent(event, chart) {
const type = EVENT_TYPES[event.type] || event.type;
const { x: x2, y: y2 } = getRelativePosition(event, chart);
return {
type,
chart,
native: event,
x: x2 !== void 0 ? x2 : null,
y: y2 !== void 0 ? y2 : null
};
}
function nodeListContains(nodeList, canvas) {
for (const node of nodeList) {
if (node === canvas || node.contains(canvas)) {
return true;
}
}
}
function createAttachObserver(chart, type, listener) {
const canvas = chart.canvas;
const observer = new MutationObserver((entries) => {
let trigger = false;
for (const entry of entries) {
trigger = trigger || nodeListContains(entry.addedNodes, canvas);
trigger = trigger && !nodeListContains(entry.removedNodes, canvas);
}
if (trigger) {
listener();
}
});
observer.observe(document, {
childList: true,
subtree: true
});
return observer;
}
function createDetachObserver(chart, type, listener) {
const canvas = chart.canvas;
const observer = new MutationObserver((entries) => {
let trigger = false;
for (const entry of entries) {
trigger = trigger || nodeListContains(entry.removedNodes, canvas);
trigger = trigger && !nodeListContains(entry.addedNodes, canvas);
}
if (trigger) {
listener();
}
});
observer.observe(document, {
childList: true,
subtree: true
});
return observer;
}
var drpListeningCharts = /* @__PURE__ */ new Map();
var oldDevicePixelRatio = 0;
function onWindowResize() {
const dpr = window.devicePixelRatio;
if (dpr === oldDevicePixelRatio) {
return;
}
oldDevicePixelRatio = dpr;
drpListeningCharts.forEach((resize, chart) => {
if (chart.currentDevicePixelRatio !== dpr) {
resize();
}
});
}
function listenDevicePixelRatioChanges(chart, resize) {
if (!drpListeningCharts.size) {
window.addEventListener("resize", onWindowResize);
}
drpListeningCharts.set(chart, resize);
}
function unlistenDevicePixelRatioChanges(chart) {
drpListeningCharts.delete(chart);
if (!drpListeningCharts.size) {
window.removeEventListener("resize", onWindowResize);
}
}
function createResizeObserver(chart, type, listener) {
const canvas = chart.canvas;
const container = canvas && _getParentNode(canvas);
if (!container) {
return;
}
const resize = throttled((width, height) => {
const w2 = container.clientWidth;
listener(width, height);
if (w2 < container.clientWidth) {
listener();
}
}, window);
const observer = new ResizeObserver((entries) => {
const entry = entries[0];
const width = entry.contentRect.width;
const height = entry.contentRect.height;
if (width === 0 && height === 0) {
return;
}
resize(width, height);
});
observer.observe(container);
listenDevicePixelRatioChanges(chart, resize);
return observer;
}
function releaseObserver(chart, type, observer) {
if (observer) {
observer.disconnect();
}
if (type === "resize") {
unlistenDevicePixelRatioChanges(chart);
}
}
function createProxyAndListen(chart, type, listener) {
const canvas = chart.canvas;
const proxy = throttled((event) => {
if (chart.ctx !== null) {
listener(fromNativeEvent(event, chart));
}
}, chart);
addListener(canvas, type, proxy);
return proxy;
}
var DomPlatform = class extends BasePlatform {
acquireContext(canvas, aspectRatio) {
const context = canvas && canvas.getContext && canvas.getContext("2d");
if (context && context.canvas === canvas) {
initCanvas(canvas, aspectRatio);
return context;
}
return null;
}
releaseContext(context) {
const canvas = context.canvas;
if (!canvas[EXPANDO_KEY]) {
return false;
}
const initial = canvas[EXPANDO_KEY].initial;
[
"height",
"width"
].forEach((prop) => {
const value = initial[prop];
if (isNullOrUndef(value)) {
canvas.removeAttribute(prop);
} else {
canvas.setAttribute(prop, value);
}
});
const style = initial.style || {};
Object.keys(style).forEach((key) => {
canvas.style[key] = style[key];
});
canvas.width = canvas.width;
delete canvas[EXPANDO_KEY];
return true;
}
addEventListener(chart, type, listener) {
this.removeEventListener(chart, type);
const proxies = chart.$proxies || (chart.$proxies = {});
const handlers = {
attach: createAttachObserver,
detach: createDetachObserver,
resize: createResizeObserver
};
const handler = handlers[type] || createProxyAndListen;
proxies[type] = handler(chart, type, listener);
}
removeEventListener(chart, type) {
const proxies = chart.$proxies || (chart.$proxies = {});
const proxy = proxies[type];
if (!proxy) {
return;
}
const handlers = {
attach: releaseObserver,
detach: releaseObserver,
resize: releaseObserver
};
const handler = handlers[type] || removeListener;
handler(chart, type, proxy);
proxies[type] = void 0;
}
getDevicePixelRatio() {
return window.devicePixelRatio;
}
getMaximumSize(canvas, width, height, aspectRatio) {
return getMaximumSize(canvas, width, height, aspectRatio);
}
isAttached(canvas) {
const container = canvas && _getParentNode(canvas);
return !!(container && container.isConnected);
}
};
function _detectPlatform(canvas) {
if (!_isDomSupported() || typeof OffscreenCanvas !== "undefined" && canvas instanceof OffscreenCanvas) {
return BasicPlatform;
}
return DomPlatform;
}
var Element = class {
constructor() {
__publicField(this, "x");
__publicField(this, "y");
__publicField(this, "active", false);
__publicField(this, "options");
__publicField(this, "$animations");
}
tooltipPosition(useFinalPosition) {
const { x: x2, y: y2 } = this.getProps([
"x",
"y"
], useFinalPosition);
return {
x: x2,
y: y2
};
}
hasValue() {
return isNumber(this.x) && isNumber(this.y);
}
getProps(props, final) {
const anims = this.$animations;
if (!final || !anims) {
return this;
}
const ret = {};
props.forEach((prop) => {
ret[prop] = anims[prop] && anims[prop].active() ? anims[prop]._to : this[prop];
});
return ret;
}
};
__publicField(Element, "defaults", {});
__publicField(Element, "defaultRoutes");
function autoSkip(scale, ticks) {
const tickOpts = scale.options.ticks;
const determinedMaxTicks = determineMaxTicks(scale);
const ticksLimit = Math.min(tickOpts.maxTicksLimit || determinedMaxTicks, determinedMaxTicks);
const majorIndices = tickOpts.major.enabled ? getMajorIndices(ticks) : [];
const numMajorIndices = majorIndices.length;
const first = majorIndices[0];
const last = majorIndices[numMajorIndices - 1];
const newTicks = [];
if (numMajorIndices > ticksLimit) {
skipMajors(ticks, newTicks, majorIndices, numMajorIndices / ticksLimit);
return newTicks;
}
const spacing = calculateSpacing(majorIndices, ticks, ticksLimit);
if (numMajorIndices > 0) {
let i2, ilen;
const avgMajorSpacing = numMajorIndices > 1 ? Math.round((last - first) / (numMajorIndices - 1)) : null;
skip(ticks, newTicks, spacing, isNullOrUndef(avgMajorSpacing) ? 0 : first - avgMajorSpacing, first);
for (i2 = 0, ilen = numMajorIndices - 1; i2 < ilen; i2++) {
skip(ticks, newTicks, spacing, majorIndices[i2], majorIndices[i2 + 1]);
}
skip(ticks, newTicks, spacing, last, isNullOrUndef(avgMajorSpacing) ? ticks.length : last + avgMajorSpacing);
return newTicks;
}
skip(ticks, newTicks, spacing);
return newTicks;
}
function determineMaxTicks(scale) {
const offset = scale.options.offset;
const tickLength = scale._tickSize();
const maxScale = scale._length / tickLength + (offset ? 0 : 1);
const maxChart = scale._maxLength / tickLength;
return Math.floor(Math.min(maxScale, maxChart));
}
function calculateSpacing(majorIndices, ticks, ticksLimit) {
const evenMajorSpacing = getEvenSpacing(majorIndices);
const spacing = ticks.length / ticksLimit;
if (!evenMajorSpacing) {
return Math.max(spacing, 1);
}
const factors = _factorize(evenMajorSpacing);
for (let i2 = 0, ilen = factors.length - 1; i2 < ilen; i2++) {
const factor = factors[i2];
if (factor > spacing) {
return factor;
}
}
return Math.max(spacing, 1);
}
function getMajorIndices(ticks) {
const result = [];
let i2, ilen;
for (i2 = 0, ilen = ticks.length; i2 < ilen; i2++) {
if (ticks[i2].major) {
result.push(i2);
}
}
return result;
}
function skipMajors(ticks, newTicks, majorIndices, spacing) {
let count = 0;
let next = majorIndices[0];
let i2;
spacing = Math.ceil(spacing);
for (i2 = 0; i2 < ticks.length; i2++) {
if (i2 === next) {
newTicks.push(ticks[i2]);
count++;
next = majorIndices[count * spacing];
}
}
}
function skip(ticks, newTicks, spacing, majorStart, majorEnd) {
const start = valueOrDefault(majorStart, 0);
const end = Math.min(valueOrDefault(majorEnd, ticks.length), ticks.length);
let count = 0;
let length, i2, next;
spacing = Math.ceil(spacing);
if (majorEnd) {
length = majorEnd - majorStart;
spacing = length / Math.floor(length / spacing);
}
next = start;
while (next < 0) {
count++;
next = Math.round(start + count * spacing);
}
for (i2 = Math.max(start, 0); i2 < end; i2++) {
if (i2 === next) {
newTicks.push(ticks[i2]);
count++;
next = Math.round(start + count * spacing);
}
}
}
function getEvenSpacing(arr) {
const len = arr.length;
let i2, diff;
if (len < 2) {
return false;
}
for (diff = arr[0], i2 = 1; i2 < len; ++i2) {
if (arr[i2] - arr[i2 - 1] !== diff) {
return false;
}
}
return diff;
}
var reverseAlign = (align) => align === "left" ? "right" : align === "right" ? "left" : align;
var offsetFromEdge = (scale, edge, offset) => edge === "top" || edge === "left" ? scale[edge] + offset : scale[edge] - offset;
var getTicksLimit = (ticksLength, maxTicksLimit) => Math.min(maxTicksLimit || ticksLength, ticksLength);
function sample(arr, numItems) {
const result = [];
const increment = arr.length / numItems;
const len = arr.length;
let i2 = 0;
for (; i2 < len; i2 += increment) {
result.push(arr[Math.floor(i2)]);
}
return result;
}
function getPixelForGridLine(scale, index, offsetGridLines) {
const length = scale.ticks.length;
const validIndex2 = Math.min(index, length - 1);
const start = scale._startPixel;
const end = scale._endPixel;
const epsilon = 1e-6;
let lineValue = scale.getPixelForTick(validIndex2);
let offset;
if (offsetGridLines) {
if (length === 1) {
offset = Math.max(lineValue - start, end - lineValue);
} else if (index === 0) {
offset = (scale.getPixelForTick(1) - lineValue) / 2;
} else {
offset = (lineValue - scale.getPixelForTick(validIndex2 - 1)) / 2;
}
lineValue += validIndex2 < index ? offset : -offset;
if (lineValue < start - epsilon || lineValue > end + epsilon) {
return;
}
}
return lineValue;
}
function garbageCollect(caches, length) {
each(caches, (cache) => {
const gc = cache.gc;
const gcLen = gc.length / 2;
let i2;
if (gcLen > length) {
for (i2 = 0; i2 < gcLen; ++i2) {
delete cache.data[gc[i2]];
}
gc.splice(0, gcLen);
}
});
}
function getTickMarkLength(options) {
return options.drawTicks ? options.tickLength : 0;
}
function getTitleHeight(options, fallback) {
if (!options.display) {
return 0;
}
const font = toFont(options.font, fallback);
const padding = toPadding(options.padding);
const lines = isArray(options.text) ? options.text.length : 1;
return lines * font.lineHeight + padding.height;
}
function createScaleContext(parent, scale) {
return createContext(parent, {
scale,
type: "scale"
});
}
function createTickContext(parent, index, tick) {
return createContext(parent, {
tick,
index,
type: "tick"
});
}
function titleAlign(align, position, reverse) {
let ret = _toLeftRightCenter(align);
if (reverse && position !== "right" || !reverse && position === "right") {
ret = reverseAlign(ret);
}
return ret;
}
function titleArgs(scale, offset, position, align) {
const { top, left, bottom, right, chart } = scale;
const { chartArea, scales } = chart;
let rotation = 0;
let maxWidth, titleX, titleY;
const height = bottom - top;
const width = right - left;
if (scale.isHorizontal()) {
titleX = _alignStartEnd(align, left, right);
if (isObject(position)) {
const positionAxisID = Object.keys(position)[0];
const value = position[positionAxisID];
titleY = scales[positionAxisID].getPixelForValue(value) + height - offset;
} else if (position === "center") {
titleY = (chartArea.bottom + chartArea.top) / 2 + height - offset;
} else {
titleY = offsetFromEdge(scale, position, offset);
}
maxWidth = right - left;
} else {
if (isObject(position)) {
const positionAxisID = Object.keys(position)[0];
const value = position[positionAxisID];
titleX = scales[positionAxisID].getPixelForValue(value) - width + offset;
} else if (position === "center") {
titleX = (chartArea.left + chartArea.right) / 2 - width + offset;
} else {
titleX = offsetFromEdge(scale, position, offset);
}
titleY = _alignStartEnd(align, bottom, top);
rotation = position === "left" ? -HALF_PI : HALF_PI;
}
return {
titleX,
titleY,
maxWidth,
rotation
};
}
var Scale = class _Scale extends Element {
constructor(cfg) {
super();
this.id = cfg.id;
this.type = cfg.type;
this.options = void 0;
this.ctx = cfg.ctx;
this.chart = cfg.chart;
this.top = void 0;
this.bottom = void 0;
this.left = void 0;
this.right = void 0;
this.width = void 0;
this.height = void 0;
this._margins = {
left: 0,
right: 0,
top: 0,
bottom: 0
};
this.maxWidth = void 0;
this.maxHeight = void 0;
this.paddingTop = void 0;
this.paddingBottom = void 0;
this.paddingLeft = void 0;
this.paddingRight = void 0;
this.axis = void 0;
this.labelRotation = void 0;
this.min = void 0;
this.max = void 0;
this._range = void 0;
this.ticks = [];
this._gridLineItems = null;
this._labelItems = null;
this._labelSizes = null;
this._length = 0;
this._maxLength = 0;
this._longestTextCache = {};
this._startPixel = void 0;
this._endPixel = void 0;
this._reversePixels = false;
this._userMax = void 0;
this._userMin = void 0;
this._suggestedMax = void 0;
this._suggestedMin = void 0;
this._ticksLength = 0;
this._borderValue = 0;
this._cache = {};
this._dataLimitsCached = false;
this.$context = void 0;
}
init(options) {
this.options = options.setContext(this.getContext());
this.axis = options.axis;
this._userMin = this.parse(options.min);
this._userMax = this.parse(options.max);
this._suggestedMin = this.parse(options.suggestedMin);
this._suggestedMax = this.parse(options.suggestedMax);
}
parse(raw, index) {
return raw;
}
getUserBounds() {
let { _userMin, _userMax, _suggestedMin, _suggestedMax } = this;
_userMin = finiteOrDefault(_userMin, Number.POSITIVE_INFINITY);
_userMax = finiteOrDefault(_userMax, Number.NEGATIVE_INFINITY);
_suggestedMin = finiteOrDefault(_suggestedMin, Number.POSITIVE_INFINITY);
_suggestedMax = finiteOrDefault(_suggestedMax, Number.NEGATIVE_INFINITY);
return {
min: finiteOrDefault(_userMin, _suggestedMin),
max: finiteOrDefault(_userMax, _suggestedMax),
minDefined: isNumberFinite(_userMin),
maxDefined: isNumberFinite(_userMax)
};
}
getMinMax(canStack) {
let { min, max, minDefined, maxDefined } = this.getUserBounds();
let range;
if (minDefined && maxDefined) {
return {
min,
max
};
}
const metas = this.getMatchingVisibleMetas();
for (let i2 = 0, ilen = metas.length; i2 < ilen; ++i2) {
range = metas[i2].controller.getMinMax(this, canStack);
if (!minDefined) {
min = Math.min(min, range.min);
}
if (!maxDefined) {
max = Math.max(max, range.max);
}
}
min = maxDefined && min > max ? max : min;
max = minDefined && min > max ? min : max;
return {
min: finiteOrDefault(min, finiteOrDefault(max, min)),
max: finiteOrDefault(max, finiteOrDefault(min, max))
};
}
getPadding() {
return {
left: this.paddingLeft || 0,
top: this.paddingTop || 0,
right: this.paddingRight || 0,
bottom: this.paddingBottom || 0
};
}
getTicks() {
return this.ticks;
}
getLabels() {
const data = this.chart.data;
return this.options.labels || (this.isHorizontal() ? data.xLabels : data.yLabels) || data.labels || [];
}
getLabelItems(chartArea = this.chart.chartArea) {
const items = this._labelItems || (this._labelItems = this._computeLabelItems(chartArea));
return items;
}
beforeLayout() {
this._cache = {};
this._dataLimitsCached = false;
}
beforeUpdate() {
callback(this.options.beforeUpdate, [
this
]);
}
update(maxWidth, maxHeight, margins) {
const { beginAtZero, grace, ticks: tickOpts } = this.options;
const sampleSize = tickOpts.sampleSize;
this.beforeUpdate();
this.maxWidth = maxWidth;
this.maxHeight = maxHeight;
this._margins = margins = Object.assign({
left: 0,
right: 0,
top: 0,
bottom: 0
}, margins);
this.ticks = null;
this._labelSizes = null;
this._gridLineItems = null;
this._labelItems = null;
this.beforeSetDimensions();
this.setDimensions();
this.afterSetDimensions();
this._maxLength = this.isHorizontal() ? this.width + margins.left + margins.right : this.height + margins.top + margins.bottom;
if (!this._dataLimitsCached) {
this.beforeDataLimits();
this.determineDataLimits();
this.afterDataLimits();
this._range = _addGrace(this, grace, beginAtZero);
this._dataLimitsCached = true;
}
this.beforeBuildTicks();
this.ticks = this.buildTicks() || [];
this.afterBuildTicks();
const samplingEnabled = sampleSize < this.ticks.length;
this._convertTicksToLabels(samplingEnabled ? sample(this.ticks, sampleSize) : this.ticks);
this.configure();
this.beforeCalculateLabelRotation();
this.calculateLabelRotation();
this.afterCalculateLabelRotation();
if (tickOpts.display && (tickOpts.autoSkip || tickOpts.source === "auto")) {
this.ticks = autoSkip(this, this.ticks);
this._labelSizes = null;
this.afterAutoSkip();
}
if (samplingEnabled) {
this._convertTicksToLabels(this.ticks);
}
this.beforeFit();
this.fit();
this.afterFit();
this.afterUpdate();
}
configure() {
let reversePixels = this.options.reverse;
let startPixel, endPixel;
if (this.isHorizontal()) {
startPixel = this.left;
endPixel = this.right;
} else {
startPixel = this.top;
endPixel = this.bottom;
reversePixels = !reversePixels;
}
this._startPixel = startPixel;
this._endPixel = endPixel;
this._reversePixels = reversePixels;
this._length = endPixel - startPixel;
this._alignToPixels = this.options.alignToPixels;
}
afterUpdate() {
callback(this.options.afterUpdate, [
this
]);
}
beforeSetDimensions() {
callback(this.options.beforeSetDimensions, [
this
]);
}
setDimensions() {
if (this.isHorizontal()) {
this.width = this.maxWidth;
this.left = 0;
this.right = this.width;
} else {
this.height = this.maxHeight;
this.top = 0;
this.bottom = this.height;
}
this.paddingLeft = 0;
this.paddingTop = 0;
this.paddingRight = 0;
this.paddingBottom = 0;
}
afterSetDimensions() {
callback(this.options.afterSetDimensions, [
this
]);
}
_callHooks(name) {
this.chart.notifyPlugins(name, this.getContext());
callback(this.options[name], [
this
]);
}
beforeDataLimits() {
this._callHooks("beforeDataLimits");
}
determineDataLimits() {
}
afterDataLimits() {
this._callHooks("afterDataLimits");
}
beforeBuildTicks() {
this._callHooks("beforeBuildTicks");
}
buildTicks() {
return [];
}
afterBuildTicks() {
this._callHooks("afterBuildTicks");
}
beforeTickToLabelConversion() {
callback(this.options.beforeTickToLabelConversion, [
this
]);
}
generateTickLabels(ticks) {
const tickOpts = this.options.ticks;
let i2, ilen, tick;
for (i2 = 0, ilen = ticks.length; i2 < ilen; i2++) {
tick = ticks[i2];
tick.label = callback(tickOpts.callback, [
tick.value,
i2,
ticks
], this);
}
}
afterTickToLabelConversion() {
callback(this.options.afterTickToLabelConversion, [
this
]);
}
beforeCalculateLabelRotation() {
callback(this.options.beforeCalculateLabelRotation, [
this
]);
}
calculateLabelRotation() {
const options = this.options;
const tickOpts = options.ticks;
const numTicks = getTicksLimit(this.ticks.length, options.ticks.maxTicksLimit);
const minRotation = tickOpts.minRotation || 0;
const maxRotation = tickOpts.maxRotation;
let labelRotation = minRotation;
let tickWidth, maxHeight, maxLabelDiagonal;
if (!this._isVisible() || !tickOpts.display || minRotation >= maxRotation || numTicks <= 1 || !this.isHorizontal()) {
this.labelRotation = minRotation;
return;
}
const labelSizes = this._getLabelSizes();
const maxLabelWidth = labelSizes.widest.width;
const maxLabelHeight = labelSizes.highest.height;
const maxWidth = _limitValue(this.chart.width - maxLabelWidth, 0, this.maxWidth);
tickWidth = options.offset ? this.maxWidth / numTicks : maxWidth / (numTicks - 1);
if (maxLabelWidth + 6 > tickWidth) {
tickWidth = maxWidth / (numTicks - (options.offset ? 0.5 : 1));
maxHeight = this.maxHeight - getTickMarkLength(options.grid) - tickOpts.padding - getTitleHeight(options.title, this.chart.options.font);
maxLabelDiagonal = Math.sqrt(maxLabelWidth * maxLabelWidth + maxLabelHeight * maxLabelHeight);
labelRotation = toDegrees(Math.min(Math.asin(_limitValue((labelSizes.highest.height + 6) / tickWidth, -1, 1)), Math.asin(_limitValue(maxHeight / maxLabelDiagonal, -1, 1)) - Math.asin(_limitValue(maxLabelHeight / maxLabelDiagonal, -1, 1))));
labelRotation = Math.max(minRotation, Math.min(maxRotation, labelRotation));
}
this.labelRotation = labelRotation;
}
afterCalculateLabelRotation() {
callback(this.options.afterCalculateLabelRotation, [
this
]);
}
afterAutoSkip() {
}
beforeFit() {
callback(this.options.beforeFit, [
this
]);
}
fit() {
const minSize = {
width: 0,
height: 0
};
const { chart, options: { ticks: tickOpts, title: titleOpts, grid: gridOpts } } = this;
const display = this._isVisible();
const isHorizontal = this.isHorizontal();
if (display) {
const titleHeight = getTitleHeight(titleOpts, chart.options.font);
if (isHorizontal) {
minSize.width = this.maxWidth;
minSize.height = getTickMarkLength(gridOpts) + titleHeight;
} else {
minSize.height = this.maxHeight;
minSize.width = getTickMarkLength(gridOpts) + titleHeight;
}
if (tickOpts.display && this.ticks.length) {
const { first, last, widest, highest } = this._getLabelSizes();
const tickPadding = tickOpts.padding * 2;
const angleRadians = toRadians(this.labelRotation);
const cos = Math.cos(angleRadians);
const sin = Math.sin(angleRadians);
if (isHorizontal) {
const labelHeight = tickOpts.mirror ? 0 : sin * widest.width + cos * highest.height;
minSize.height = Math.min(this.maxHeight, minSize.height + labelHeight + tickPadding);
} else {
const labelWidth = tickOpts.mirror ? 0 : cos * widest.width + sin * highest.height;
minSize.width = Math.min(this.maxWidth, minSize.width + labelWidth + tickPadding);
}
this._calculatePadding(first, last, sin, cos);
}
}
this._handleMargins();
if (isHorizontal) {
this.width = this._length = chart.width - this._margins.left - this._margins.right;
this.height = minSize.height;
} else {
this.width = minSize.width;
this.height = this._length = chart.height - this._margins.top - this._margins.bottom;
}
}
_calculatePadding(first, last, sin, cos) {
const { ticks: { align, padding }, position } = this.options;
const isRotated = this.labelRotation !== 0;
const labelsBelowTicks = position !== "top" && this.axis === "x";
if (this.isHorizontal()) {
const offsetLeft = this.getPixelForTick(0) - this.left;
const offsetRight = this.right - this.getPixelForTick(this.ticks.length - 1);
let paddingLeft = 0;
let paddingRight = 0;
if (isRotated) {
if (labelsBelowTicks) {
paddingLeft = cos * first.width;
paddingRight = sin * last.height;
} else {
paddingLeft = sin * first.height;
paddingRight = cos * last.width;
}
} else if (align === "start") {
paddingRight = last.width;
} else if (align === "end") {
paddingLeft = first.width;
} else if (align !== "inner") {
paddingLeft = first.width / 2;
paddingRight = last.width / 2;
}
this.paddingLeft = Math.max((paddingLeft - offsetLeft + padding) * this.width / (this.width - offsetLeft), 0);
this.paddingRight = Math.max((paddingRight - offsetRight + padding) * this.width / (this.width - offsetRight), 0);
} else {
let paddingTop = last.height / 2;
let paddingBottom = first.height / 2;
if (align === "start") {
paddingTop = 0;
paddingBottom = first.height;
} else if (align === "end") {
paddingTop = last.height;
paddingBottom = 0;
}
this.paddingTop = paddingTop + padding;
this.paddingBottom = paddingBottom + padding;
}
}
_handleMargins() {
if (this._margins) {
this._margins.left = Math.max(this.paddingLeft, this._margins.left);
this._margins.top = Math.max(this.paddingTop, this._margins.top);
this._margins.right = Math.max(this.paddingRight, this._margins.right);
this._margins.bottom = Math.max(this.paddingBottom, this._margins.bottom);
}
}
afterFit() {
callback(this.options.afterFit, [
this
]);
}
isHorizontal() {
const { axis, position } = this.options;
return position === "top" || position === "bottom" || axis === "x";
}
isFullSize() {
return this.options.fullSize;
}
_convertTicksToLabels(ticks) {
this.beforeTickToLabelConversion();
this.generateTickLabels(ticks);
let i2, ilen;
for (i2 = 0, ilen = ticks.length; i2 < ilen; i2++) {
if (isNullOrUndef(ticks[i2].label)) {
ticks.splice(i2, 1);
ilen--;
i2--;
}
}
this.afterTickToLabelConversion();
}
_getLabelSizes() {
let labelSizes = this._labelSizes;
if (!labelSizes) {
const sampleSize = this.options.ticks.sampleSize;
let ticks = this.ticks;
if (sampleSize < ticks.length) {
ticks = sample(ticks, sampleSize);
}
this._labelSizes = labelSizes = this._computeLabelSizes(ticks, ticks.length, this.options.ticks.maxTicksLimit);
}
return labelSizes;
}
_computeLabelSizes(ticks, length, maxTicksLimit) {
const { ctx, _longestTextCache: caches } = this;
const widths = [];
const heights = [];
const increment = Math.floor(length / getTicksLimit(length, maxTicksLimit));
let widestLabelSize = 0;
let highestLabelSize = 0;
let i2, j2, jlen, label, tickFont, fontString, cache, lineHeight, width, height, nestedLabel;
for (i2 = 0; i2 < length; i2 += increment) {
label = ticks[i2].label;
tickFont = this._resolveTickFontOptions(i2);
ctx.font = fontString = tickFont.string;
cache = caches[fontString] = caches[fontString] || {
data: {},
gc: []
};
lineHeight = tickFont.lineHeight;
width = height = 0;
if (!isNullOrUndef(label) && !isArray(label)) {
width = _measureText(ctx, cache.data, cache.gc, width, label);
height = lineHeight;
} else if (isArray(label)) {
for (j2 = 0, jlen = label.length; j2 < jlen; ++j2) {
nestedLabel = label[j2];
if (!isNullOrUndef(nestedLabel) && !isArray(nestedLabel)) {
width = _measureText(ctx, cache.data, cache.gc, width, nestedLabel);
height += lineHeight;
}
}
}
widths.push(width);
heights.push(height);
widestLabelSize = Math.max(width, widestLabelSize);
highestLabelSize = Math.max(height, highestLabelSize);
}
garbageCollect(caches, length);
const widest = widths.indexOf(widestLabelSize);
const highest = heights.indexOf(highestLabelSize);
const valueAt = (idx) => ({
width: widths[idx] || 0,
height: heights[idx] || 0
});
return {
first: valueAt(0),
last: valueAt(length - 1),
widest: valueAt(widest),
highest: valueAt(highest),
widths,
heights
};
}
getLabelForValue(value) {
return value;
}
getPixelForValue(value, index) {
return NaN;
}
getValueForPixel(pixel) {
}
getPixelForTick(index) {
const ticks = this.ticks;
if (index < 0 || index > ticks.length - 1) {
return null;
}
return this.getPixelForValue(ticks[index].value);
}
getPixelForDecimal(decimal) {
if (this._reversePixels) {
decimal = 1 - decimal;
}
const pixel = this._startPixel + decimal * this._length;
return _int16Range(this._alignToPixels ? _alignPixel(this.chart, pixel, 0) : pixel);
}
getDecimalForPixel(pixel) {
const decimal = (pixel - this._startPixel) / this._length;
return this._reversePixels ? 1 - decimal : decimal;
}
getBasePixel() {
return this.getPixelForValue(this.getBaseValue());
}
getBaseValue() {
const { min, max } = this;
return min < 0 && max < 0 ? max : min > 0 && max > 0 ? min : 0;
}
getContext(index) {
const ticks = this.ticks || [];
if (index >= 0 && index < ticks.length) {
const tick = ticks[index];
return tick.$context || (tick.$context = createTickContext(this.getContext(), index, tick));
}
return this.$context || (this.$context = createScaleContext(this.chart.getContext(), this));
}
_tickSize() {
const optionTicks = this.options.ticks;
const rot = toRadians(this.labelRotation);
const cos = Math.abs(Math.cos(rot));
const sin = Math.abs(Math.sin(rot));
const labelSizes = this._getLabelSizes();
const padding = optionTicks.autoSkipPadding || 0;
const w2 = labelSizes ? labelSizes.widest.width + padding : 0;
const h6 = labelSizes ? labelSizes.highest.height + padding : 0;
return this.isHorizontal() ? h6 * cos > w2 * sin ? w2 / cos : h6 / sin : h6 * sin < w2 * cos ? h6 / cos : w2 / sin;
}
_isVisible() {
const display = this.options.display;
if (display !== "auto") {
return !!display;
}
return this.getMatchingVisibleMetas().length > 0;
}
_computeGridLineItems(chartArea) {
const axis = this.axis;
const chart = this.chart;
const options = this.options;
const { grid, position, border } = options;
const offset = grid.offset;
const isHorizontal = this.isHorizontal();
const ticks = this.ticks;
const ticksLength = ticks.length + (offset ? 1 : 0);
const tl = getTickMarkLength(grid);
const items = [];
const borderOpts = border.setContext(this.getContext());
const axisWidth = borderOpts.display ? borderOpts.width : 0;
const axisHalfWidth = axisWidth / 2;
const alignBorderValue = function(pixel) {
return _alignPixel(chart, pixel, axisWidth);
};
let borderValue, i2, lineValue, alignedLineValue;
let tx1, ty1, tx2, ty2, x1, y1, x2, y2;
if (position === "top") {
borderValue = alignBorderValue(this.bottom);
ty1 = this.bottom - tl;
ty2 = borderValue - axisHalfWidth;
y1 = alignBorderValue(chartArea.top) + axisHalfWidth;
y2 = chartArea.bottom;
} else if (position === "bottom") {
borderValue = alignBorderValue(this.top);
y1 = chartArea.top;
y2 = alignBorderValue(chartArea.bottom) - axisHalfWidth;
ty1 = borderValue + axisHalfWidth;
ty2 = this.top + tl;
} else if (position === "left") {
borderValue = alignBorderValue(this.right);
tx1 = this.right - tl;
tx2 = borderValue - axisHalfWidth;
x1 = alignBorderValue(chartArea.left) + axisHalfWidth;
x2 = chartArea.right;
} else if (position === "right") {
borderValue = alignBorderValue(this.left);
x1 = chartArea.left;
x2 = alignBorderValue(chartArea.right) - axisHalfWidth;
tx1 = borderValue + axisHalfWidth;
tx2 = this.left + tl;
} else if (axis === "x") {
if (position === "center") {
borderValue = alignBorderValue((chartArea.top + chartArea.bottom) / 2 + 0.5);
} else if (isObject(position)) {
const positionAxisID = Object.keys(position)[0];
const value = position[positionAxisID];
borderValue = alignBorderValue(this.chart.scales[positionAxisID].getPixelForValue(value));
}
y1 = chartArea.top;
y2 = chartArea.bottom;
ty1 = borderValue + axisHalfWidth;
ty2 = ty1 + tl;
} else if (axis === "y") {
if (position === "center") {
borderValue = alignBorderValue((chartArea.left + chartArea.right) / 2);
} else if (isObject(position)) {
const positionAxisID = Object.keys(position)[0];
const value = position[positionAxisID];
borderValue = alignBorderValue(this.chart.scales[positionAxisID].getPixelForValue(value));
}
tx1 = borderValue - axisHalfWidth;
tx2 = tx1 - tl;
x1 = chartArea.left;
x2 = chartArea.right;
}
const limit = valueOrDefault(options.ticks.maxTicksLimit, ticksLength);
const step = Math.max(1, Math.ceil(ticksLength / limit));
for (i2 = 0; i2 < ticksLength; i2 += step) {
const context = this.getContext(i2);
const optsAtIndex = grid.setContext(context);
const optsAtIndexBorder = border.setContext(context);
const lineWidth = optsAtIndex.lineWidth;
const lineColor = optsAtIndex.color;
const borderDash = optsAtIndexBorder.dash || [];
const borderDashOffset = optsAtIndexBorder.dashOffset;
const tickWidth = optsAtIndex.tickWidth;
const tickColor = optsAtIndex.tickColor;
const tickBorderDash = optsAtIndex.tickBorderDash || [];
const tickBorderDashOffset = optsAtIndex.tickBorderDashOffset;
lineValue = getPixelForGridLine(this, i2, offset);
if (lineValue === void 0) {
continue;
}
alignedLineValue = _alignPixel(chart, lineValue, lineWidth);
if (isHorizontal) {
tx1 = tx2 = x1 = x2 = alignedLineValue;
} else {
ty1 = ty2 = y1 = y2 = alignedLineValue;
}
items.push({
tx1,
ty1,
tx2,
ty2,
x1,
y1,
x2,
y2,
width: lineWidth,
color: lineColor,
borderDash,
borderDashOffset,
tickWidth,
tickColor,
tickBorderDash,
tickBorderDashOffset
});
}
this._ticksLength = ticksLength;
this._borderValue = borderValue;
return items;
}
_computeLabelItems(chartArea) {
const axis = this.axis;
const options = this.options;
const { position, ticks: optionTicks } = options;
const isHorizontal = this.isHorizontal();
const ticks = this.ticks;
const { align, crossAlign, padding, mirror } = optionTicks;
const tl = getTickMarkLength(options.grid);
const tickAndPadding = tl + padding;
const hTickAndPadding = mirror ? -padding : tickAndPadding;
const rotation = -toRadians(this.labelRotation);
const items = [];
let i2, ilen, tick, label, x2, y2, textAlign, pixel, font, lineHeight, lineCount, textOffset;
let textBaseline = "middle";
if (position === "top") {
y2 = this.bottom - hTickAndPadding;
textAlign = this._getXAxisLabelAlignment();
} else if (position === "bottom") {
y2 = this.top + hTickAndPadding;
textAlign = this._getXAxisLabelAlignment();
} else if (position === "left") {
const ret = this._getYAxisLabelAlignment(tl);
textAlign = ret.textAlign;
x2 = ret.x;
} else if (position === "right") {
const ret = this._getYAxisLabelAlignment(tl);
textAlign = ret.textAlign;
x2 = ret.x;
} else if (axis === "x") {
if (position === "center") {
y2 = (chartArea.top + chartArea.bottom) / 2 + tickAndPadding;
} else if (isObject(position)) {
const positionAxisID = Object.keys(position)[0];
const value = position[positionAxisID];
y2 = this.chart.scales[positionAxisID].getPixelForValue(value) + tickAndPadding;
}
textAlign = this._getXAxisLabelAlignment();
} else if (axis === "y") {
if (position === "center") {
x2 = (chartArea.left + chartArea.right) / 2 - tickAndPadding;
} else if (isObject(position)) {
const positionAxisID = Object.keys(position)[0];
const value = position[positionAxisID];
x2 = this.chart.scales[positionAxisID].getPixelForValue(value);
}
textAlign = this._getYAxisLabelAlignment(tl).textAlign;
}
if (axis === "y") {
if (align === "start") {
textBaseline = "top";
} else if (align === "end") {
textBaseline = "bottom";
}
}
const labelSizes = this._getLabelSizes();
for (i2 = 0, ilen = ticks.length; i2 < ilen; ++i2) {
tick = ticks[i2];
label = tick.label;
const optsAtIndex = optionTicks.setContext(this.getContext(i2));
pixel = this.getPixelForTick(i2) + optionTicks.labelOffset;
font = this._resolveTickFontOptions(i2);
lineHeight = font.lineHeight;
lineCount = isArray(label) ? label.length : 1;
const halfCount = lineCount / 2;
const color2 = optsAtIndex.color;
const strokeColor = optsAtIndex.textStrokeColor;
const strokeWidth = optsAtIndex.textStrokeWidth;
let tickTextAlign = textAlign;
if (isHorizontal) {
x2 = pixel;
if (textAlign === "inner") {
if (i2 === ilen - 1) {
tickTextAlign = !this.options.reverse ? "right" : "left";
} else if (i2 === 0) {
tickTextAlign = !this.options.reverse ? "left" : "right";
} else {
tickTextAlign = "center";
}
}
if (position === "top") {
if (crossAlign === "near" || rotation !== 0) {
textOffset = -lineCount * lineHeight + lineHeight / 2;
} else if (crossAlign === "center") {
textOffset = -labelSizes.highest.height / 2 - halfCount * lineHeight + lineHeight;
} else {
textOffset = -labelSizes.highest.height + lineHeight / 2;
}
} else {
if (crossAlign === "near" || rotation !== 0) {
textOffset = lineHeight / 2;
} else if (crossAlign === "center") {
textOffset = labelSizes.highest.height / 2 - halfCount * lineHeight;
} else {
textOffset = labelSizes.highest.height - lineCount * lineHeight;
}
}
if (mirror) {
textOffset *= -1;
}
if (rotation !== 0 && !optsAtIndex.showLabelBackdrop) {
x2 += lineHeight / 2 * Math.sin(rotation);
}
} else {
y2 = pixel;
textOffset = (1 - lineCount) * lineHeight / 2;
}
let backdrop;
if (optsAtIndex.showLabelBackdrop) {
const labelPadding = toPadding(optsAtIndex.backdropPadding);
const height = labelSizes.heights[i2];
const width = labelSizes.widths[i2];
let top = textOffset - labelPadding.top;
let left = 0 - labelPadding.left;
switch (textBaseline) {
case "middle":
top -= height / 2;
break;
case "bottom":
top -= height;
break;
}
switch (textAlign) {
case "center":
left -= width / 2;
break;
case "right":
left -= width;
break;
case "inner":
if (i2 === ilen - 1) {
left -= width;
} else if (i2 > 0) {
left -= width / 2;
}
break;
}
backdrop = {
left,
top,
width: width + labelPadding.width,
height: height + labelPadding.height,
color: optsAtIndex.backdropColor
};
}
items.push({
label,
font,
textOffset,
options: {
rotation,
color: color2,
strokeColor,
strokeWidth,
textAlign: tickTextAlign,
textBaseline,
translation: [
x2,
y2
],
backdrop
}
});
}
return items;
}
_getXAxisLabelAlignment() {
const { position, ticks } = this.options;
const rotation = -toRadians(this.labelRotation);
if (rotation) {
return position === "top" ? "left" : "right";
}
let align = "center";
if (ticks.align === "start") {
align = "left";
} else if (ticks.align === "end") {
align = "right";
} else if (ticks.align === "inner") {
align = "inner";
}
return align;
}
_getYAxisLabelAlignment(tl) {
const { position, ticks: { crossAlign, mirror, padding } } = this.options;
const labelSizes = this._getLabelSizes();
const tickAndPadding = tl + padding;
const widest = labelSizes.widest.width;
let textAlign;
let x2;
if (position === "left") {
if (mirror) {
x2 = this.right + padding;
if (crossAlign === "near") {
textAlign = "left";
} else if (crossAlign === "center") {
textAlign = "center";
x2 += widest / 2;
} else {
textAlign = "right";
x2 += widest;
}
} else {
x2 = this.right - tickAndPadding;
if (crossAlign === "near") {
textAlign = "right";
} else if (crossAlign === "center") {
textAlign = "center";
x2 -= widest / 2;
} else {
textAlign = "left";
x2 = this.left;
}
}
} else if (position === "right") {
if (mirror) {
x2 = this.left + padding;
if (crossAlign === "near") {
textAlign = "right";
} else if (crossAlign === "center") {
textAlign = "center";
x2 -= widest / 2;
} else {
textAlign = "left";
x2 -= widest;
}
} else {
x2 = this.left + tickAndPadding;
if (crossAlign === "near") {
textAlign = "left";
} else if (crossAlign === "center") {
textAlign = "center";
x2 += widest / 2;
} else {
textAlign = "right";
x2 = this.right;
}
}
} else {
textAlign = "right";
}
return {
textAlign,
x: x2
};
}
_computeLabelArea() {
if (this.options.ticks.mirror) {
return;
}
const chart = this.chart;
const position = this.options.position;
if (position === "left" || position === "right") {
return {
top: 0,
left: this.left,
bottom: chart.height,
right: this.right
};
}
if (position === "top" || position === "bottom") {
return {
top: this.top,
left: 0,
bottom: this.bottom,
right: chart.width
};
}
}
drawBackground() {
const { ctx, options: { backgroundColor }, left, top, width, height } = this;
if (backgroundColor) {
ctx.save();
ctx.fillStyle = backgroundColor;
ctx.fillRect(left, top, width, height);
ctx.restore();
}
}
getLineWidthForValue(value) {
const grid = this.options.grid;
if (!this._isVisible() || !grid.display) {
return 0;
}
const ticks = this.ticks;
const index = ticks.findIndex((t3) => t3.value === value);
if (index >= 0) {
const opts = grid.setContext(this.getContext(index));
return opts.lineWidth;
}
return 0;
}
drawGrid(chartArea) {
const grid = this.options.grid;
const ctx = this.ctx;
const items = this._gridLineItems || (this._gridLineItems = this._computeGridLineItems(chartArea));
let i2, ilen;
const drawLine = (p1, p2, style) => {
if (!style.width || !style.color) {
return;
}
ctx.save();
ctx.lineWidth = style.width;
ctx.strokeStyle = style.color;
ctx.setLineDash(style.borderDash || []);
ctx.lineDashOffset = style.borderDashOffset;
ctx.beginPath();
ctx.moveTo(p1.x, p1.y);
ctx.lineTo(p2.x, p2.y);
ctx.stroke();
ctx.restore();
};
if (grid.display) {
for (i2 = 0, ilen = items.length; i2 < ilen; ++i2) {
const item = items[i2];
if (grid.drawOnChartArea) {
drawLine({
x: item.x1,
y: item.y1
}, {
x: item.x2,
y: item.y2
}, item);
}
if (grid.drawTicks) {
drawLine({
x: item.tx1,
y: item.ty1
}, {
x: item.tx2,
y: item.ty2
}, {
color: item.tickColor,
width: item.tickWidth,
borderDash: item.tickBorderDash,
borderDashOffset: item.tickBorderDashOffset
});
}
}
}
}
drawBorder() {
const { chart, ctx, options: { border, grid } } = this;
const borderOpts = border.setContext(this.getContext());
const axisWidth = border.display ? borderOpts.width : 0;
if (!axisWidth) {
return;
}
const lastLineWidth = grid.setContext(this.getContext(0)).lineWidth;
const borderValue = this._borderValue;
let x1, x2, y1, y2;
if (this.isHorizontal()) {
x1 = _alignPixel(chart, this.left, axisWidth) - axisWidth / 2;
x2 = _alignPixel(chart, this.right, lastLineWidth) + lastLineWidth / 2;
y1 = y2 = borderValue;
} else {
y1 = _alignPixel(chart, this.top, axisWidth) - axisWidth / 2;
y2 = _alignPixel(chart, this.bottom, lastLineWidth) + lastLineWidth / 2;
x1 = x2 = borderValue;
}
ctx.save();
ctx.lineWidth = borderOpts.width;
ctx.strokeStyle = borderOpts.color;
ctx.beginPath();
ctx.moveTo(x1, y1);
ctx.lineTo(x2, y2);
ctx.stroke();
ctx.restore();
}
drawLabels(chartArea) {
const optionTicks = this.options.ticks;
if (!optionTicks.display) {
return;
}
const ctx = this.ctx;
const area = this._computeLabelArea();
if (area) {
clipArea(ctx, area);
}
const items = this.getLabelItems(chartArea);
for (const item of items) {
const renderTextOptions = item.options;
const tickFont = item.font;
const label = item.label;
const y2 = item.textOffset;
renderText(ctx, label, 0, y2, tickFont, renderTextOptions);
}
if (area) {
unclipArea(ctx);
}
}
drawTitle() {
const { ctx, options: { position, title, reverse } } = this;
if (!title.display) {
return;
}
const font = toFont(title.font);
const padding = toPadding(title.padding);
const align = title.align;
let offset = font.lineHeight / 2;
if (position === "bottom" || position === "center" || isObject(position)) {
offset += padding.bottom;
if (isArray(title.text)) {
offset += font.lineHeight * (title.text.length - 1);
}
} else {
offset += padding.top;
}
const { titleX, titleY, maxWidth, rotation } = titleArgs(this, offset, position, align);
renderText(ctx, title.text, 0, 0, font, {
color: title.color,
maxWidth,
rotation,
textAlign: titleAlign(align, position, reverse),
textBaseline: "middle",
translation: [
titleX,
titleY
]
});
}
draw(chartArea) {
if (!this._isVisible()) {
return;
}
this.drawBackground();
this.drawGrid(chartArea);
this.drawBorder();
this.drawTitle();
this.drawLabels(chartArea);
}
_layers() {
const opts = this.options;
const tz = opts.ticks && opts.ticks.z || 0;
const gz = valueOrDefault(opts.grid && opts.grid.z, -1);
const bz = valueOrDefault(opts.border && opts.border.z, 0);
if (!this._isVisible() || this.draw !== _Scale.prototype.draw) {
return [
{
z: tz,
draw: (chartArea) => {
this.draw(chartArea);
}
}
];
}
return [
{
z: gz,
draw: (chartArea) => {
this.drawBackground();
this.drawGrid(chartArea);
this.drawTitle();
}
},
{
z: bz,
draw: () => {
this.drawBorder();
}
},
{
z: tz,
draw: (chartArea) => {
this.drawLabels(chartArea);
}
}
];
}
getMatchingVisibleMetas(type) {
const metas = this.chart.getSortedVisibleDatasetMetas();
const axisID = this.axis + "AxisID";
const result = [];
let i2, ilen;
for (i2 = 0, ilen = metas.length; i2 < ilen; ++i2) {
const meta = metas[i2];
if (meta[axisID] === this.id && (!type || meta.type === type)) {
result.push(meta);
}
}
return result;
}
_resolveTickFontOptions(index) {
const opts = this.options.ticks.setContext(this.getContext(index));
return toFont(opts.font);
}
_maxDigits() {
const fontSize = this._resolveTickFontOptions(0).lineHeight;
return (this.isHorizontal() ? this.width : this.height) / fontSize;
}
};
var TypedRegistry = class {
constructor(type, scope, override) {
this.type = type;
this.scope = scope;
this.override = override;
this.items = /* @__PURE__ */ Object.create(null);
}
isForType(type) {
return Object.prototype.isPrototypeOf.call(this.type.prototype, type.prototype);
}
register(item) {
const proto = Object.getPrototypeOf(item);
let parentScope;
if (isIChartComponent(proto)) {
parentScope = this.register(proto);
}
const items = this.items;
const id = item.id;
const scope = this.scope + "." + id;
if (!id) {
throw new Error("class does not have id: " + item);
}
if (id in items) {
return scope;
}
items[id] = item;
registerDefaults(item, scope, parentScope);
if (this.override) {
defaults2.override(item.id, item.overrides);
}
return scope;
}
get(id) {
return this.items[id];
}
unregister(item) {
const items = this.items;
const id = item.id;
const scope = this.scope;
if (id in items) {
delete items[id];
}
if (scope && id in defaults2[scope]) {
delete defaults2[scope][id];
if (this.override) {
delete overrides[id];
}
}
}
};
function registerDefaults(item, scope, parentScope) {
const itemDefaults = merge(/* @__PURE__ */ Object.create(null), [
parentScope ? defaults2.get(parentScope) : {},
defaults2.get(scope),
item.defaults
]);
defaults2.set(scope, itemDefaults);
if (item.defaultRoutes) {
routeDefaults(scope, item.defaultRoutes);
}
if (item.descriptors) {
defaults2.describe(scope, item.descriptors);
}
}
function routeDefaults(scope, routes) {
Object.keys(routes).forEach((property) => {
const propertyParts = property.split(".");
const sourceName = propertyParts.pop();
const sourceScope = [
scope
].concat(propertyParts).join(".");
const parts = routes[property].split(".");
const targetName = parts.pop();
const targetScope = parts.join(".");
defaults2.route(sourceScope, sourceName, targetScope, targetName);
});
}
function isIChartComponent(proto) {
return "id" in proto && "defaults" in proto;
}
var Registry = class {
constructor() {
this.controllers = new TypedRegistry(DatasetController, "datasets", true);
this.elements = new TypedRegistry(Element, "elements");
this.plugins = new TypedRegistry(Object, "plugins");
this.scales = new TypedRegistry(Scale, "scales");
this._typedRegistries = [
this.controllers,
this.scales,
this.elements
];
}
add(...args) {
this._each("register", args);
}
remove(...args) {
this._each("unregister", args);
}
addControllers(...args) {
this._each("register", args, this.controllers);
}
addElements(...args) {
this._each("register", args, this.elements);
}
addPlugins(...args) {
this._each("register", args, this.plugins);
}
addScales(...args) {
this._each("register", args, this.scales);
}
getController(id) {
return this._get(id, this.controllers, "controller");
}
getElement(id) {
return this._get(id, this.elements, "element");
}
getPlugin(id) {
return this._get(id, this.plugins, "plugin");
}
getScale(id) {
return this._get(id, this.scales, "scale");
}
removeControllers(...args) {
this._each("unregister", args, this.controllers);
}
removeElements(...args) {
this._each("unregister", args, this.elements);
}
removePlugins(...args) {
this._each("unregister", args, this.plugins);
}
removeScales(...args) {
this._each("unregister", args, this.scales);
}
_each(method, args, typedRegistry) {
[
...args
].forEach((arg) => {
const reg = typedRegistry || this._getRegistryForType(arg);
if (typedRegistry || reg.isForType(arg) || reg === this.plugins && arg.id) {
this._exec(method, reg, arg);
} else {
each(arg, (item) => {
const itemReg = typedRegistry || this._getRegistryForType(item);
this._exec(method, itemReg, item);
});
}
});
}
_exec(method, registry2, component) {
const camelMethod = _capitalize(method);
callback(component["before" + camelMethod], [], component);
registry2[method](component);
callback(component["after" + camelMethod], [], component);
}
_getRegistryForType(type) {
for (let i2 = 0; i2 < this._typedRegistries.length; i2++) {
const reg = this._typedRegistries[i2];
if (reg.isForType(type)) {
return reg;
}
}
return this.plugins;
}
_get(id, typedRegistry, type) {
const item = typedRegistry.get(id);
if (item === void 0) {
throw new Error('"' + id + '" is not a registered ' + type + ".");
}
return item;
}
};
var registry = /* @__PURE__ */ new Registry();
var PluginService = class {
constructor() {
this._init = [];
}
notify(chart, hook, args, filter2) {
if (hook === "beforeInit") {
this._init = this._createDescriptors(chart, true);
this._notify(this._init, chart, "install");
}
const descriptors2 = filter2 ? this._descriptors(chart).filter(filter2) : this._descriptors(chart);
const result = this._notify(descriptors2, chart, hook, args);
if (hook === "afterDestroy") {
this._notify(descriptors2, chart, "stop");
this._notify(this._init, chart, "uninstall");
}
return result;
}
_notify(descriptors2, chart, hook, args) {
args = args || {};
for (const descriptor of descriptors2) {
const plugin = descriptor.plugin;
const method = plugin[hook];
const params = [
chart,
args,
descriptor.options
];
if (callback(method, params, plugin) === false && args.cancelable) {
return false;
}
}
return true;
}
invalidate() {
if (!isNullOrUndef(this._cache)) {
this._oldCache = this._cache;
this._cache = void 0;
}
}
_descriptors(chart) {
if (this._cache) {
return this._cache;
}
const descriptors2 = this._cache = this._createDescriptors(chart);
this._notifyStateChanges(chart);
return descriptors2;
}
_createDescriptors(chart, all) {
const config = chart && chart.config;
const options = valueOrDefault(config.options && config.options.plugins, {});
const plugins = allPlugins(config);
return options === false && !all ? [] : createDescriptors(chart, plugins, options, all);
}
_notifyStateChanges(chart) {
const previousDescriptors = this._oldCache || [];
const descriptors2 = this._cache;
const diff = (a2, b2) => a2.filter((x2) => !b2.some((y2) => x2.plugin.id === y2.plugin.id));
this._notify(diff(previousDescriptors, descriptors2), chart, "stop");
this._notify(diff(descriptors2, previousDescriptors), chart, "start");
}
};
function allPlugins(config) {
const localIds = {};
const plugins = [];
const keys = Object.keys(registry.plugins.items);
for (let i2 = 0; i2 < keys.length; i2++) {
plugins.push(registry.getPlugin(keys[i2]));
}
const local = config.plugins || [];
for (let i2 = 0; i2 < local.length; i2++) {
const plugin = local[i2];
if (plugins.indexOf(plugin) === -1) {
plugins.push(plugin);
localIds[plugin.id] = true;
}
}
return {
plugins,
localIds
};
}
function getOpts(options, all) {
if (!all && options === false) {
return null;
}
if (options === true) {
return {};
}
return options;
}
function createDescriptors(chart, { plugins, localIds }, options, all) {
const result = [];
const context = chart.getContext();
for (const plugin of plugins) {
const id = plugin.id;
const opts = getOpts(options[id], all);
if (opts === null) {
continue;
}
result.push({
plugin,
options: pluginOpts(chart.config, {
plugin,
local: localIds[id]
}, opts, context)
});
}
return result;
}
function pluginOpts(config, { plugin, local }, opts, context) {
const keys = config.pluginScopeKeys(plugin);
const scopes = config.getOptionScopes(opts, keys);
if (local && plugin.defaults) {
scopes.push(plugin.defaults);
}
return config.createResolver(scopes, context, [
""
], {
scriptable: false,
indexable: false,
allKeys: true
});
}
function getIndexAxis(type, options) {
const datasetDefaults = defaults2.datasets[type] || {};
const datasetOptions = (options.datasets || {})[type] || {};
return datasetOptions.indexAxis || options.indexAxis || datasetDefaults.indexAxis || "x";
}
function getAxisFromDefaultScaleID(id, indexAxis) {
let axis = id;
if (id === "_index_") {
axis = indexAxis;
} else if (id === "_value_") {
axis = indexAxis === "x" ? "y" : "x";
}
return axis;
}
function getDefaultScaleIDFromAxis(axis, indexAxis) {
return axis === indexAxis ? "_index_" : "_value_";
}
function idMatchesAxis(id) {
if (id === "x" || id === "y" || id === "r") {
return id;
}
}
function axisFromPosition(position) {
if (position === "top" || position === "bottom") {
return "x";
}
if (position === "left" || position === "right") {
return "y";
}
}
function determineAxis(id, ...scaleOptions) {
if (idMatchesAxis(id)) {
return id;
}
for (const opts of scaleOptions) {
const axis = opts.axis || axisFromPosition(opts.position) || id.length > 1 && idMatchesAxis(id[0].toLowerCase());
if (axis) {
return axis;
}
}
throw new Error(`Cannot determine type of '${id}' axis. Please provide 'axis' or 'position' option.`);
}
function getAxisFromDataset(id, axis, dataset) {
if (dataset[axis + "AxisID"] === id) {
return {
axis
};
}
}
function retrieveAxisFromDatasets(id, config) {
if (config.data && config.data.datasets) {
const boundDs = config.data.datasets.filter((d2) => d2.xAxisID === id || d2.yAxisID === id);
if (boundDs.length) {
return getAxisFromDataset(id, "x", boundDs[0]) || getAxisFromDataset(id, "y", boundDs[0]);
}
}
return {};
}
function mergeScaleConfig(config, options) {
const chartDefaults = overrides[config.type] || {
scales: {}
};
const configScales = options.scales || {};
const chartIndexAxis = getIndexAxis(config.type, options);
const scales = /* @__PURE__ */ Object.create(null);
Object.keys(configScales).forEach((id) => {
const scaleConf = configScales[id];
if (!isObject(scaleConf)) {
return console.error(`Invalid scale configuration for scale: ${id}`);
}
if (scaleConf._proxy) {
return console.warn(`Ignoring resolver passed as options for scale: ${id}`);
}
const axis = determineAxis(id, scaleConf, retrieveAxisFromDatasets(id, config), defaults2.scales[scaleConf.type]);
const defaultId = getDefaultScaleIDFromAxis(axis, chartIndexAxis);
const defaultScaleOptions = chartDefaults.scales || {};
scales[id] = mergeIf(/* @__PURE__ */ Object.create(null), [
{
axis
},
scaleConf,
defaultScaleOptions[axis],
defaultScaleOptions[defaultId]
]);
});
config.data.datasets.forEach((dataset) => {
const type = dataset.type || config.type;
const indexAxis = dataset.indexAxis || getIndexAxis(type, options);
const datasetDefaults = overrides[type] || {};
const defaultScaleOptions = datasetDefaults.scales || {};
Object.keys(defaultScaleOptions).forEach((defaultID) => {
const axis = getAxisFromDefaultScaleID(defaultID, indexAxis);
const id = dataset[axis + "AxisID"] || axis;
scales[id] = scales[id] || /* @__PURE__ */ Object.create(null);
mergeIf(scales[id], [
{
axis
},
configScales[id],
defaultScaleOptions[defaultID]
]);
});
});
Object.keys(scales).forEach((key) => {
const scale = scales[key];
mergeIf(scale, [
defaults2.scales[scale.type],
defaults2.scale
]);
});
return scales;
}
function initOptions(config) {
const options = config.options || (config.options = {});
options.plugins = valueOrDefault(options.plugins, {});
options.scales = mergeScaleConfig(config, options);
}
function initData(data) {
data = data || {};
data.datasets = data.datasets || [];
data.labels = data.labels || [];
return data;
}
function initConfig(config) {
config = config || {};
config.data = initData(config.data);
initOptions(config);
return config;
}
var keyCache = /* @__PURE__ */ new Map();
var keysCached = /* @__PURE__ */ new Set();
function cachedKeys(cacheKey, generate) {
let keys = keyCache.get(cacheKey);
if (!keys) {
keys = generate();
keyCache.set(cacheKey, keys);
keysCached.add(keys);
}
return keys;
}
var addIfFound = (set2, obj, key) => {
const opts = resolveObjectKey(obj, key);
if (opts !== void 0) {
set2.add(opts);
}
};
var Config = class {
constructor(config) {
this._config = initConfig(config);
this._scopeCache = /* @__PURE__ */ new Map();
this._resolverCache = /* @__PURE__ */ new Map();
}
get platform() {
return this._config.platform;
}
get type() {
return this._config.type;
}
set type(type) {
this._config.type = type;
}
get data() {
return this._config.data;
}
set data(data) {
this._config.data = initData(data);
}
get options() {
return this._config.options;
}
set options(options) {
this._config.options = options;
}
get plugins() {
return this._config.plugins;
}
update() {
const config = this._config;
this.clearCache();
initOptions(config);
}
clearCache() {
this._scopeCache.clear();
this._resolverCache.clear();
}
datasetScopeKeys(datasetType) {
return cachedKeys(datasetType, () => [
[
`datasets.${datasetType}`,
""
]
]);
}
datasetAnimationScopeKeys(datasetType, transition) {
return cachedKeys(`${datasetType}.transition.${transition}`, () => [
[
`datasets.${datasetType}.transitions.${transition}`,
`transitions.${transition}`
],
[
`datasets.${datasetType}`,
""
]
]);
}
datasetElementScopeKeys(datasetType, elementType) {
return cachedKeys(`${datasetType}-${elementType}`, () => [
[
`datasets.${datasetType}.elements.${elementType}`,
`datasets.${datasetType}`,
`elements.${elementType}`,
""
]
]);
}
pluginScopeKeys(plugin) {
const id = plugin.id;
const type = this.type;
return cachedKeys(`${type}-plugin-${id}`, () => [
[
`plugins.${id}`,
...plugin.additionalOptionScopes || []
]
]);
}
_cachedScopes(mainScope, resetCache) {
const _scopeCache = this._scopeCache;
let cache = _scopeCache.get(mainScope);
if (!cache || resetCache) {
cache = /* @__PURE__ */ new Map();
_scopeCache.set(mainScope, cache);
}
return cache;
}
getOptionScopes(mainScope, keyLists, resetCache) {
const { options, type } = this;
const cache = this._cachedScopes(mainScope, resetCache);
const cached = cache.get(keyLists);
if (cached) {
return cached;
}
const scopes = /* @__PURE__ */ new Set();
keyLists.forEach((keys) => {
if (mainScope) {
scopes.add(mainScope);
keys.forEach((key) => addIfFound(scopes, mainScope, key));
}
keys.forEach((key) => addIfFound(scopes, options, key));
keys.forEach((key) => addIfFound(scopes, overrides[type] || {}, key));
keys.forEach((key) => addIfFound(scopes, defaults2, key));
keys.forEach((key) => addIfFound(scopes, descriptors, key));
});
const array = Array.from(scopes);
if (array.length === 0) {
array.push(/* @__PURE__ */ Object.create(null));
}
if (keysCached.has(keyLists)) {
cache.set(keyLists, array);
}
return array;
}
chartOptionScopes() {
const { options, type } = this;
return [
options,
overrides[type] || {},
defaults2.datasets[type] || {},
{
type
},
defaults2,
descriptors
];
}
resolveNamedOptions(scopes, names2, context, prefixes = [
""
]) {
const result = {
$shared: true
};
const { resolver, subPrefixes } = getResolver(this._resolverCache, scopes, prefixes);
let options = resolver;
if (needContext(resolver, names2)) {
result.$shared = false;
context = isFunction(context) ? context() : context;
const subResolver = this.createResolver(scopes, context, subPrefixes);
options = _attachContext(resolver, context, subResolver);
}
for (const prop of names2) {
result[prop] = options[prop];
}
return result;
}
createResolver(scopes, context, prefixes = [
""
], descriptorDefaults) {
const { resolver } = getResolver(this._resolverCache, scopes, prefixes);
return isObject(context) ? _attachContext(resolver, context, void 0, descriptorDefaults) : resolver;
}
};
function getResolver(resolverCache, scopes, prefixes) {
let cache = resolverCache.get(scopes);
if (!cache) {
cache = /* @__PURE__ */ new Map();
resolverCache.set(scopes, cache);
}
const cacheKey = prefixes.join();
let cached = cache.get(cacheKey);
if (!cached) {
const resolver = _createResolver(scopes, prefixes);
cached = {
resolver,
subPrefixes: prefixes.filter((p2) => !p2.toLowerCase().includes("hover"))
};
cache.set(cacheKey, cached);
}
return cached;
}
var hasFunction = (value) => isObject(value) && Object.getOwnPropertyNames(value).some((key) => isFunction(value[key]));
function needContext(proxy, names2) {
const { isScriptable, isIndexable } = _descriptors(proxy);
for (const prop of names2) {
const scriptable = isScriptable(prop);
const indexable = isIndexable(prop);
const value = (indexable || scriptable) && proxy[prop];
if (scriptable && (isFunction(value) || hasFunction(value)) || indexable && isArray(value)) {
return true;
}
}
return false;
}
var version = "4.4.4";
var KNOWN_POSITIONS = [
"top",
"bottom",
"left",
"right",
"chartArea"
];
function positionIsHorizontal(position, axis) {
return position === "top" || position === "bottom" || KNOWN_POSITIONS.indexOf(position) === -1 && axis === "x";
}
function compare2Level(l1, l2) {
return function(a2, b2) {
return a2[l1] === b2[l1] ? a2[l2] - b2[l2] : a2[l1] - b2[l1];
};
}
function onAnimationsComplete(context) {
const chart = context.chart;
const animationOptions = chart.options.animation;
chart.notifyPlugins("afterRender");
callback(animationOptions && animationOptions.onComplete, [
context
], chart);
}
function onAnimationProgress(context) {
const chart = context.chart;
const animationOptions = chart.options.animation;
callback(animationOptions && animationOptions.onProgress, [
context
], chart);
}
function getCanvas(item) {
if (_isDomSupported() && typeof item === "string") {
item = document.getElementById(item);
} else if (item && item.length) {
item = item[0];
}
if (item && item.canvas) {
item = item.canvas;
}
return item;
}
var instances = {};
var getChart = (key) => {
const canvas = getCanvas(key);
return Object.values(instances).filter((c2) => c2.canvas === canvas).pop();
};
function moveNumericKeys(obj, start, move) {
const keys = Object.keys(obj);
for (const key of keys) {
const intKey = +key;
if (intKey >= start) {
const value = obj[key];
delete obj[key];
if (move > 0 || intKey > start) {
obj[intKey + move] = value;
}
}
}
}
function determineLastEvent(e2, lastEvent, inChartArea, isClick) {
if (!inChartArea || e2.type === "mouseout") {
return null;
}
if (isClick) {
return lastEvent;
}
return e2;
}
function getSizeForArea(scale, chartArea, field) {
return scale.options.clip ? scale[field] : chartArea[field];
}
function getDatasetArea(meta, chartArea) {
const { xScale, yScale } = meta;
if (xScale && yScale) {
return {
left: getSizeForArea(xScale, chartArea, "left"),
right: getSizeForArea(xScale, chartArea, "right"),
top: getSizeForArea(yScale, chartArea, "top"),
bottom: getSizeForArea(yScale, chartArea, "bottom")
};
}
return chartArea;
}
var Chart = class {
static register(...items) {
registry.add(...items);
invalidatePlugins();
}
static unregister(...items) {
registry.remove(...items);
invalidatePlugins();
}
constructor(item, userConfig) {
const config = this.config = new Config(userConfig);
const initialCanvas = getCanvas(item);
const existingChart = getChart(initialCanvas);
if (existingChart) {
throw new Error("Canvas is already in use. Chart with ID '" + existingChart.id + "' must be destroyed before the canvas with ID '" + existingChart.canvas.id + "' can be reused.");
}
const options = config.createResolver(config.chartOptionScopes(), this.getContext());
this.platform = new (config.platform || _detectPlatform(initialCanvas))();
this.platform.updateConfig(config);
const context = this.platform.acquireContext(initialCanvas, options.aspectRatio);
const canvas = context && context.canvas;
const height = canvas && canvas.height;
const width = canvas && canvas.width;
this.id = uid();
this.ctx = context;
this.canvas = canvas;
this.width = width;
this.height = height;
this._options = options;
this._aspectRatio = this.aspectRatio;
this._layers = [];
this._metasets = [];
this._stacks = void 0;
this.boxes = [];
this.currentDevicePixelRatio = void 0;
this.chartArea = void 0;
this._active = [];
this._lastEvent = void 0;
this._listeners = {};
this._responsiveListeners = void 0;
this._sortedMetasets = [];
this.scales = {};
this._plugins = new PluginService();
this.$proxies = {};
this._hiddenIndices = {};
this.attached = false;
this._animationsDisabled = void 0;
this.$context = void 0;
this._doResize = debounce((mode) => this.update(mode), options.resizeDelay || 0);
this._dataChanges = [];
instances[this.id] = this;
if (!context || !canvas) {
console.error("Failed to create chart: can't acquire context from the given item");
return;
}
animator.listen(this, "complete", onAnimationsComplete);
animator.listen(this, "progress", onAnimationProgress);
this._initialize();
if (this.attached) {
this.update();
}
}
get aspectRatio() {
const { options: { aspectRatio, maintainAspectRatio }, width, height, _aspectRatio } = this;
if (!isNullOrUndef(aspectRatio)) {
return aspectRatio;
}
if (maintainAspectRatio && _aspectRatio) {
return _aspectRatio;
}
return height ? width / height : null;
}
get data() {
return this.config.data;
}
set data(data) {
this.config.data = data;
}
get options() {
return this._options;
}
set options(options) {
this.config.options = options;
}
get registry() {
return registry;
}
_initialize() {
this.notifyPlugins("beforeInit");
if (this.options.responsive) {
this.resize();
} else {
retinaScale(this, this.options.devicePixelRatio);
}
this.bindEvents();
this.notifyPlugins("afterInit");
return this;
}
clear() {
clearCanvas(this.canvas, this.ctx);
return this;
}
stop() {
animator.stop(this);
return this;
}
resize(width, height) {
if (!animator.running(this)) {
this._resize(width, height);
} else {
this._resizeBeforeDraw = {
width,
height
};
}
}
_resize(width, height) {
const options = this.options;
const canvas = this.canvas;
const aspectRatio = options.maintainAspectRatio && this.aspectRatio;
const newSize = this.platform.getMaximumSize(canvas, width, height, aspectRatio);
const newRatio = options.devicePixelRatio || this.platform.getDevicePixelRatio();
const mode = this.width ? "resize" : "attach";
this.width = newSize.width;
this.height = newSize.height;
this._aspectRatio = this.aspectRatio;
if (!retinaScale(this, newRatio, true)) {
return;
}
this.notifyPlugins("resize", {
size: newSize
});
callback(options.onResize, [
this,
newSize
], this);
if (this.attached) {
if (this._doResize(mode)) {
this.render();
}
}
}
ensureScalesHaveIDs() {
const options = this.options;
const scalesOptions = options.scales || {};
each(scalesOptions, (axisOptions, axisID) => {
axisOptions.id = axisID;
});
}
buildOrUpdateScales() {
const options = this.options;
const scaleOpts = options.scales;
const scales = this.scales;
const updated = Object.keys(scales).reduce((obj, id) => {
obj[id] = false;
return obj;
}, {});
let items = [];
if (scaleOpts) {
items = items.concat(Object.keys(scaleOpts).map((id) => {
const scaleOptions = scaleOpts[id];
const axis = determineAxis(id, scaleOptions);
const isRadial = axis === "r";
const isHorizontal = axis === "x";
return {
options: scaleOptions,
dposition: isRadial ? "chartArea" : isHorizontal ? "bottom" : "left",
dtype: isRadial ? "radialLinear" : isHorizontal ? "category" : "linear"
};
}));
}
each(items, (item) => {
const scaleOptions = item.options;
const id = scaleOptions.id;
const axis = determineAxis(id, scaleOptions);
const scaleType = valueOrDefault(scaleOptions.type, item.dtype);
if (scaleOptions.position === void 0 || positionIsHorizontal(scaleOptions.position, axis) !== positionIsHorizontal(item.dposition)) {
scaleOptions.position = item.dposition;
}
updated[id] = true;
let scale = null;
if (id in scales && scales[id].type === scaleType) {
scale = scales[id];
} else {
const scaleClass = registry.getScale(scaleType);
scale = new scaleClass({
id,
type: scaleType,
ctx: this.ctx,
chart: this
});
scales[scale.id] = scale;
}
scale.init(scaleOptions, options);
});
each(updated, (hasUpdated, id) => {
if (!hasUpdated) {
delete scales[id];
}
});
each(scales, (scale) => {
layouts.configure(this, scale, scale.options);
layouts.addBox(this, scale);
});
}
_updateMetasets() {
const metasets = this._metasets;
const numData = this.data.datasets.length;
const numMeta = metasets.length;
metasets.sort((a2, b2) => a2.index - b2.index);
if (numMeta > numData) {
for (let i2 = numData; i2 < numMeta; ++i2) {
this._destroyDatasetMeta(i2);
}
metasets.splice(numData, numMeta - numData);
}
this._sortedMetasets = metasets.slice(0).sort(compare2Level("order", "index"));
}
_removeUnreferencedMetasets() {
const { _metasets: metasets, data: { datasets } } = this;
if (metasets.length > datasets.length) {
delete this._stacks;
}
metasets.forEach((meta, index) => {
if (datasets.filter((x2) => x2 === meta._dataset).length === 0) {
this._destroyDatasetMeta(index);
}
});
}
buildOrUpdateControllers() {
const newControllers = [];
const datasets = this.data.datasets;
let i2, ilen;
this._removeUnreferencedMetasets();
for (i2 = 0, ilen = datasets.length; i2 < ilen; i2++) {
const dataset = datasets[i2];
let meta = this.getDatasetMeta(i2);
const type = dataset.type || this.config.type;
if (meta.type && meta.type !== type) {
this._destroyDatasetMeta(i2);
meta = this.getDatasetMeta(i2);
}
meta.type = type;
meta.indexAxis = dataset.indexAxis || getIndexAxis(type, this.options);
meta.order = dataset.order || 0;
meta.index = i2;
meta.label = "" + dataset.label;
meta.visible = this.isDatasetVisible(i2);
if (meta.controller) {
meta.controller.updateIndex(i2);
meta.controller.linkScales();
} else {
const ControllerClass = registry.getController(type);
const { datasetElementType, dataElementType } = defaults2.datasets[type];
Object.assign(ControllerClass, {
dataElementType: registry.getElement(dataElementType),
datasetElementType: datasetElementType && registry.getElement(datasetElementType)
});
meta.controller = new ControllerClass(this, i2);
newControllers.push(meta.controller);
}
}
this._updateMetasets();
return newControllers;
}
_resetElements() {
each(this.data.datasets, (dataset, datasetIndex) => {
this.getDatasetMeta(datasetIndex).controller.reset();
}, this);
}
reset() {
this._resetElements();
this.notifyPlugins("reset");
}
update(mode) {
const config = this.config;
config.update();
const options = this._options = config.createResolver(config.chartOptionScopes(), this.getContext());
const animsDisabled = this._animationsDisabled = !options.animation;
this._updateScales();
this._checkEventBindings();
this._updateHiddenIndices();
this._plugins.invalidate();
if (this.notifyPlugins("beforeUpdate", {
mode,
cancelable: true
}) === false) {
return;
}
const newControllers = this.buildOrUpdateControllers();
this.notifyPlugins("beforeElementsUpdate");
let minPadding = 0;
for (let i2 = 0, ilen = this.data.datasets.length; i2 < ilen; i2++) {
const { controller } = this.getDatasetMeta(i2);
const reset2 = !animsDisabled && newControllers.indexOf(controller) === -1;
controller.buildOrUpdateElements(reset2);
minPadding = Math.max(+controller.getMaxOverflow(), minPadding);
}
minPadding = this._minPadding = options.layout.autoPadding ? minPadding : 0;
this._updateLayout(minPadding);
if (!animsDisabled) {
each(newControllers, (controller) => {
controller.reset();
});
}
this._updateDatasets(mode);
this.notifyPlugins("afterUpdate", {
mode
});
this._layers.sort(compare2Level("z", "_idx"));
const { _active, _lastEvent } = this;
if (_lastEvent) {
this._eventHandler(_lastEvent, true);
} else if (_active.length) {
this._updateHoverStyles(_active, _active, true);
}
this.render();
}
_updateScales() {
each(this.scales, (scale) => {
layouts.removeBox(this, scale);
});
this.ensureScalesHaveIDs();
this.buildOrUpdateScales();
}
_checkEventBindings() {
const options = this.options;
const existingEvents = new Set(Object.keys(this._listeners));
const newEvents = new Set(options.events);
if (!setsEqual(existingEvents, newEvents) || !!this._responsiveListeners !== options.responsive) {
this.unbindEvents();
this.bindEvents();
}
}
_updateHiddenIndices() {
const { _hiddenIndices } = this;
const changes = this._getUniformDataChanges() || [];
for (const { method, start, count } of changes) {
const move = method === "_removeElements" ? -count : count;
moveNumericKeys(_hiddenIndices, start, move);
}
}
_getUniformDataChanges() {
const _dataChanges = this._dataChanges;
if (!_dataChanges || !_dataChanges.length) {
return;
}
this._dataChanges = [];
const datasetCount = this.data.datasets.length;
const makeSet = (idx) => new Set(_dataChanges.filter((c2) => c2[0] === idx).map((c2, i2) => i2 + "," + c2.splice(1).join(",")));
const changeSet = makeSet(0);
for (let i2 = 1; i2 < datasetCount; i2++) {
if (!setsEqual(changeSet, makeSet(i2))) {
return;
}
}
return Array.from(changeSet).map((c2) => c2.split(",")).map((a2) => ({
method: a2[1],
start: +a2[2],
count: +a2[3]
}));
}
_updateLayout(minPadding) {
if (this.notifyPlugins("beforeLayout", {
cancelable: true
}) === false) {
return;
}
layouts.update(this, this.width, this.height, minPadding);
const area = this.chartArea;
const noArea = area.width <= 0 || area.height <= 0;
this._layers = [];
each(this.boxes, (box) => {
if (noArea && box.position === "chartArea") {
return;
}
if (box.configure) {
box.configure();
}
this._layers.push(...box._layers());
}, this);
this._layers.forEach((item, index) => {
item._idx = index;
});
this.notifyPlugins("afterLayout");
}
_updateDatasets(mode) {
if (this.notifyPlugins("beforeDatasetsUpdate", {
mode,
cancelable: true
}) === false) {
return;
}
for (let i2 = 0, ilen = this.data.datasets.length; i2 < ilen; ++i2) {
this.getDatasetMeta(i2).controller.configure();
}
for (let i2 = 0, ilen = this.data.datasets.length; i2 < ilen; ++i2) {
this._updateDataset(i2, isFunction(mode) ? mode({
datasetIndex: i2
}) : mode);
}
this.notifyPlugins("afterDatasetsUpdate", {
mode
});
}
_updateDataset(index, mode) {
const meta = this.getDatasetMeta(index);
const args = {
meta,
index,
mode,
cancelable: true
};
if (this.notifyPlugins("beforeDatasetUpdate", args) === false) {
return;
}
meta.controller._update(mode);
args.cancelable = false;
this.notifyPlugins("afterDatasetUpdate", args);
}
render() {
if (this.notifyPlugins("beforeRender", {
cancelable: true
}) === false) {
return;
}
if (animator.has(this)) {
if (this.attached && !animator.running(this)) {
animator.start(this);
}
} else {
this.draw();
onAnimationsComplete({
chart: this
});
}
}
draw() {
let i2;
if (this._resizeBeforeDraw) {
const { width, height } = this._resizeBeforeDraw;
this._resizeBeforeDraw = null;
this._resize(width, height);
}
this.clear();
if (this.width <= 0 || this.height <= 0) {
return;
}
if (this.notifyPlugins("beforeDraw", {
cancelable: true
}) === false) {
return;
}
const layers = this._layers;
for (i2 = 0; i2 < layers.length && layers[i2].z <= 0; ++i2) {
layers[i2].draw(this.chartArea);
}
this._drawDatasets();
for (; i2 < layers.length; ++i2) {
layers[i2].draw(this.chartArea);
}
this.notifyPlugins("afterDraw");
}
_getSortedDatasetMetas(filterVisible) {
const metasets = this._sortedMetasets;
const result = [];
let i2, ilen;
for (i2 = 0, ilen = metasets.length; i2 < ilen; ++i2) {
const meta = metasets[i2];
if (!filterVisible || meta.visible) {
result.push(meta);
}
}
return result;
}
getSortedVisibleDatasetMetas() {
return this._getSortedDatasetMetas(true);
}
_drawDatasets() {
if (this.notifyPlugins("beforeDatasetsDraw", {
cancelable: true
}) === false) {
return;
}
const metasets = this.getSortedVisibleDatasetMetas();
for (let i2 = metasets.length - 1; i2 >= 0; --i2) {
this._drawDataset(metasets[i2]);
}
this.notifyPlugins("afterDatasetsDraw");
}
_drawDataset(meta) {
const ctx = this.ctx;
const clip = meta._clip;
const useClip = !clip.disabled;
const area = getDatasetArea(meta, this.chartArea);
const args = {
meta,
index: meta.index,
cancelable: true
};
if (this.notifyPlugins("beforeDatasetDraw", args) === false) {
return;
}
if (useClip) {
clipArea(ctx, {
left: clip.left === false ? 0 : area.left - clip.left,
right: clip.right === false ? this.width : area.right + clip.right,
top: clip.top === false ? 0 : area.top - clip.top,
bottom: clip.bottom === false ? this.height : area.bottom + clip.bottom
});
}
meta.controller.draw();
if (useClip) {
unclipArea(ctx);
}
args.cancelable = false;
this.notifyPlugins("afterDatasetDraw", args);
}
isPointInArea(point) {
return _isPointInArea(point, this.chartArea, this._minPadding);
}
getElementsAtEventForMode(e2, mode, options, useFinalPosition) {
const method = Interaction.modes[mode];
if (typeof method === "function") {
return method(this, e2, options, useFinalPosition);
}
return [];
}
getDatasetMeta(datasetIndex) {
const dataset = this.data.datasets[datasetIndex];
const metasets = this._metasets;
let meta = metasets.filter((x2) => x2 && x2._dataset === dataset).pop();
if (!meta) {
meta = {
type: null,
data: [],
dataset: null,
controller: null,
hidden: null,
xAxisID: null,
yAxisID: null,
order: dataset && dataset.order || 0,
index: datasetIndex,
_dataset: dataset,
_parsed: [],
_sorted: false
};
metasets.push(meta);
}
return meta;
}
getContext() {
return this.$context || (this.$context = createContext(null, {
chart: this,
type: "chart"
}));
}
getVisibleDatasetCount() {
return this.getSortedVisibleDatasetMetas().length;
}
isDatasetVisible(datasetIndex) {
const dataset = this.data.datasets[datasetIndex];
if (!dataset) {
return false;
}
const meta = this.getDatasetMeta(datasetIndex);
return typeof meta.hidden === "boolean" ? !meta.hidden : !dataset.hidden;
}
setDatasetVisibility(datasetIndex, visible) {
const meta = this.getDatasetMeta(datasetIndex);
meta.hidden = !visible;
}
toggleDataVisibility(index) {
this._hiddenIndices[index] = !this._hiddenIndices[index];
}
getDataVisibility(index) {
return !this._hiddenIndices[index];
}
_updateVisibility(datasetIndex, dataIndex, visible) {
const mode = visible ? "show" : "hide";
const meta = this.getDatasetMeta(datasetIndex);
const anims = meta.controller._resolveAnimations(void 0, mode);
if (defined(dataIndex)) {
meta.data[dataIndex].hidden = !visible;
this.update();
} else {
this.setDatasetVisibility(datasetIndex, visible);
anims.update(meta, {
visible
});
this.update((ctx) => ctx.datasetIndex === datasetIndex ? mode : void 0);
}
}
hide(datasetIndex, dataIndex) {
this._updateVisibility(datasetIndex, dataIndex, false);
}
show(datasetIndex, dataIndex) {
this._updateVisibility(datasetIndex, dataIndex, true);
}
_destroyDatasetMeta(datasetIndex) {
const meta = this._metasets[datasetIndex];
if (meta && meta.controller) {
meta.controller._destroy();
}
delete this._metasets[datasetIndex];
}
_stop() {
let i2, ilen;
this.stop();
animator.remove(this);
for (i2 = 0, ilen = this.data.datasets.length; i2 < ilen; ++i2) {
this._destroyDatasetMeta(i2);
}
}
destroy() {
this.notifyPlugins("beforeDestroy");
const { canvas, ctx } = this;
this._stop();
this.config.clearCache();
if (canvas) {
this.unbindEvents();
clearCanvas(canvas, ctx);
this.platform.releaseContext(ctx);
this.canvas = null;
this.ctx = null;
}
delete instances[this.id];
this.notifyPlugins("afterDestroy");
}
toBase64Image(...args) {
return this.canvas.toDataURL(...args);
}
bindEvents() {
this.bindUserEvents();
if (this.options.responsive) {
this.bindResponsiveEvents();
} else {
this.attached = true;
}
}
bindUserEvents() {
const listeners = this._listeners;
const platform = this.platform;
const _add = (type, listener2) => {
platform.addEventListener(this, type, listener2);
listeners[type] = listener2;
};
const listener = (e2, x2, y2) => {
e2.offsetX = x2;
e2.offsetY = y2;
this._eventHandler(e2);
};
each(this.options.events, (type) => _add(type, listener));
}
bindResponsiveEvents() {
if (!this._responsiveListeners) {
this._responsiveListeners = {};
}
const listeners = this._responsiveListeners;
const platform = this.platform;
const _add = (type, listener2) => {
platform.addEventListener(this, type, listener2);
listeners[type] = listener2;
};
const _remove = (type, listener2) => {
if (listeners[type]) {
platform.removeEventListener(this, type, listener2);
delete listeners[type];
}
};
const listener = (width, height) => {
if (this.canvas) {
this.resize(width, height);
}
};
let detached;
const attached = () => {
_remove("attach", attached);
this.attached = true;
this.resize();
_add("resize", listener);
_add("detach", detached);
};
detached = () => {
this.attached = false;
_remove("resize", listener);
this._stop();
this._resize(0, 0);
_add("attach", attached);
};
if (platform.isAttached(this.canvas)) {
attached();
} else {
detached();
}
}
unbindEvents() {
each(this._listeners, (listener, type) => {
this.platform.removeEventListener(this, type, listener);
});
this._listeners = {};
each(this._responsiveListeners, (listener, type) => {
this.platform.removeEventListener(this, type, listener);
});
this._responsiveListeners = void 0;
}
updateHoverStyle(items, mode, enabled) {
const prefix = enabled ? "set" : "remove";
let meta, item, i2, ilen;
if (mode === "dataset") {
meta = this.getDatasetMeta(items[0].datasetIndex);
meta.controller["_" + prefix + "DatasetHoverStyle"]();
}
for (i2 = 0, ilen = items.length; i2 < ilen; ++i2) {
item = items[i2];
const controller = item && this.getDatasetMeta(item.datasetIndex).controller;
if (controller) {
controller[prefix + "HoverStyle"](item.element, item.datasetIndex, item.index);
}
}
}
getActiveElements() {
return this._active || [];
}
setActiveElements(activeElements) {
const lastActive = this._active || [];
const active = activeElements.map(({ datasetIndex, index }) => {
const meta = this.getDatasetMeta(datasetIndex);
if (!meta) {
throw new Error("No dataset found at index " + datasetIndex);
}
return {
datasetIndex,
element: meta.data[index],
index
};
});
const changed = !_elementsEqual(active, lastActive);
if (changed) {
this._active = active;
this._lastEvent = null;
this._updateHoverStyles(active, lastActive);
}
}
notifyPlugins(hook, args, filter2) {
return this._plugins.notify(this, hook, args, filter2);
}
isPluginEnabled(pluginId) {
return this._plugins._cache.filter((p2) => p2.plugin.id === pluginId).length === 1;
}
_updateHoverStyles(active, lastActive, replay) {
const hoverOptions = this.options.hover;
const diff = (a2, b2) => a2.filter((x2) => !b2.some((y2) => x2.datasetIndex === y2.datasetIndex && x2.index === y2.index));
const deactivated = diff(lastActive, active);
const activated = replay ? active : diff(active, lastActive);
if (deactivated.length) {
this.updateHoverStyle(deactivated, hoverOptions.mode, false);
}
if (activated.length && hoverOptions.mode) {
this.updateHoverStyle(activated, hoverOptions.mode, true);
}
}
_eventHandler(e2, replay) {
const args = {
event: e2,
replay,
cancelable: true,
inChartArea: this.isPointInArea(e2)
};
const eventFilter = (plugin) => (plugin.options.events || this.options.events).includes(e2.native.type);
if (this.notifyPlugins("beforeEvent", args, eventFilter) === false) {
return;
}
const changed = this._handleEvent(e2, replay, args.inChartArea);
args.cancelable = false;
this.notifyPlugins("afterEvent", args, eventFilter);
if (changed || args.changed) {
this.render();
}
return this;
}
_handleEvent(e2, replay, inChartArea) {
const { _active: lastActive = [], options } = this;
const useFinalPosition = replay;
const active = this._getActiveElements(e2, lastActive, inChartArea, useFinalPosition);
const isClick = _isClickEvent(e2);
const lastEvent = determineLastEvent(e2, this._lastEvent, inChartArea, isClick);
if (inChartArea) {
this._lastEvent = null;
callback(options.onHover, [
e2,
active,
this
], this);
if (isClick) {
callback(options.onClick, [
e2,
active,
this
], this);
}
}
const changed = !_elementsEqual(active, lastActive);
if (changed || replay) {
this._active = active;
this._updateHoverStyles(active, lastActive, replay);
}
this._lastEvent = lastEvent;
return changed;
}
_getActiveElements(e2, lastActive, inChartArea, useFinalPosition) {
if (e2.type === "mouseout") {
return [];
}
if (!inChartArea) {
return lastActive;
}
const hoverOptions = this.options.hover;
return this.getElementsAtEventForMode(e2, hoverOptions.mode, hoverOptions, useFinalPosition);
}
};
__publicField(Chart, "defaults", defaults2);
__publicField(Chart, "instances", instances);
__publicField(Chart, "overrides", overrides);
__publicField(Chart, "registry", registry);
__publicField(Chart, "version", version);
__publicField(Chart, "getChart", getChart);
function invalidatePlugins() {
return each(Chart.instances, (chart) => chart._plugins.invalidate());
}
function clipArc(ctx, element, endAngle) {
const { startAngle, pixelMargin, x: x2, y: y2, outerRadius, innerRadius } = element;
let angleMargin = pixelMargin / outerRadius;
ctx.beginPath();
ctx.arc(x2, y2, outerRadius, startAngle - angleMargin, endAngle + angleMargin);
if (innerRadius > pixelMargin) {
angleMargin = pixelMargin / innerRadius;
ctx.arc(x2, y2, innerRadius, endAngle + angleMargin, startAngle - angleMargin, true);
} else {
ctx.arc(x2, y2, pixelMargin, endAngle + HALF_PI, startAngle - HALF_PI);
}
ctx.closePath();
ctx.clip();
}
function toRadiusCorners(value) {
return _readValueToProps(value, [
"outerStart",
"outerEnd",
"innerStart",
"innerEnd"
]);
}
function parseBorderRadius$1(arc, innerRadius, outerRadius, angleDelta) {
const o2 = toRadiusCorners(arc.options.borderRadius);
const halfThickness = (outerRadius - innerRadius) / 2;
const innerLimit = Math.min(halfThickness, angleDelta * innerRadius / 2);
const computeOuterLimit = (val) => {
const outerArcLimit = (outerRadius - Math.min(halfThickness, val)) * angleDelta / 2;
return _limitValue(val, 0, Math.min(halfThickness, outerArcLimit));
};
return {
outerStart: computeOuterLimit(o2.outerStart),
outerEnd: computeOuterLimit(o2.outerEnd),
innerStart: _limitValue(o2.innerStart, 0, innerLimit),
innerEnd: _limitValue(o2.innerEnd, 0, innerLimit)
};
}
function rThetaToXY(r2, theta, x2, y2) {
return {
x: x2 + r2 * Math.cos(theta),
y: y2 + r2 * Math.sin(theta)
};
}
function pathArc(ctx, element, offset, spacing, end, circular) {
const { x: x2, y: y2, startAngle: start, pixelMargin, innerRadius: innerR } = element;
const outerRadius = Math.max(element.outerRadius + spacing + offset - pixelMargin, 0);
const innerRadius = innerR > 0 ? innerR + spacing + offset + pixelMargin : 0;
let spacingOffset = 0;
const alpha2 = end - start;
if (spacing) {
const noSpacingInnerRadius = innerR > 0 ? innerR - spacing : 0;
const noSpacingOuterRadius = outerRadius > 0 ? outerRadius - spacing : 0;
const avNogSpacingRadius = (noSpacingInnerRadius + noSpacingOuterRadius) / 2;
const adjustedAngle = avNogSpacingRadius !== 0 ? alpha2 * avNogSpacingRadius / (avNogSpacingRadius + spacing) : alpha2;
spacingOffset = (alpha2 - adjustedAngle) / 2;
}
const beta = Math.max(1e-3, alpha2 * outerRadius - offset / PI) / outerRadius;
const angleOffset = (alpha2 - beta) / 2;
const startAngle = start + angleOffset + spacingOffset;
const endAngle = end - angleOffset - spacingOffset;
const { outerStart, outerEnd, innerStart, innerEnd } = parseBorderRadius$1(element, innerRadius, outerRadius, endAngle - startAngle);
const outerStartAdjustedRadius = outerRadius - outerStart;
const outerEndAdjustedRadius = outerRadius - outerEnd;
const outerStartAdjustedAngle = startAngle + outerStart / outerStartAdjustedRadius;
const outerEndAdjustedAngle = endAngle - outerEnd / outerEndAdjustedRadius;
const innerStartAdjustedRadius = innerRadius + innerStart;
const innerEndAdjustedRadius = innerRadius + innerEnd;
const innerStartAdjustedAngle = startAngle + innerStart / innerStartAdjustedRadius;
const innerEndAdjustedAngle = endAngle - innerEnd / innerEndAdjustedRadius;
ctx.beginPath();
if (circular) {
const outerMidAdjustedAngle = (outerStartAdjustedAngle + outerEndAdjustedAngle) / 2;
ctx.arc(x2, y2, outerRadius, outerStartAdjustedAngle, outerMidAdjustedAngle);
ctx.arc(x2, y2, outerRadius, outerMidAdjustedAngle, outerEndAdjustedAngle);
if (outerEnd > 0) {
const pCenter = rThetaToXY(outerEndAdjustedRadius, outerEndAdjustedAngle, x2, y2);
ctx.arc(pCenter.x, pCenter.y, outerEnd, outerEndAdjustedAngle, endAngle + HALF_PI);
}
const p4 = rThetaToXY(innerEndAdjustedRadius, endAngle, x2, y2);
ctx.lineTo(p4.x, p4.y);
if (innerEnd > 0) {
const pCenter = rThetaToXY(innerEndAdjustedRadius, innerEndAdjustedAngle, x2, y2);
ctx.arc(pCenter.x, pCenter.y, innerEnd, endAngle + HALF_PI, innerEndAdjustedAngle + Math.PI);
}
const innerMidAdjustedAngle = (endAngle - innerEnd / innerRadius + (startAngle + innerStart / innerRadius)) / 2;
ctx.arc(x2, y2, innerRadius, endAngle - innerEnd / innerRadius, innerMidAdjustedAngle, true);
ctx.arc(x2, y2, innerRadius, innerMidAdjustedAngle, startAngle + innerStart / innerRadius, true);
if (innerStart > 0) {
const pCenter = rThetaToXY(innerStartAdjustedRadius, innerStartAdjustedAngle, x2, y2);
ctx.arc(pCenter.x, pCenter.y, innerStart, innerStartAdjustedAngle + Math.PI, startAngle - HALF_PI);
}
const p8 = rThetaToXY(outerStartAdjustedRadius, startAngle, x2, y2);
ctx.lineTo(p8.x, p8.y);
if (outerStart > 0) {
const pCenter = rThetaToXY(outerStartAdjustedRadius, outerStartAdjustedAngle, x2, y2);
ctx.arc(pCenter.x, pCenter.y, outerStart, startAngle - HALF_PI, outerStartAdjustedAngle);
}
} else {
ctx.moveTo(x2, y2);
const outerStartX = Math.cos(outerStartAdjustedAngle) * outerRadius + x2;
const outerStartY = Math.sin(outerStartAdjustedAngle) * outerRadius + y2;
ctx.lineTo(outerStartX, outerStartY);
const outerEndX = Math.cos(outerEndAdjustedAngle) * outerRadius + x2;
const outerEndY = Math.sin(outerEndAdjustedAngle) * outerRadius + y2;
ctx.lineTo(outerEndX, outerEndY);
}
ctx.closePath();
}
function drawArc(ctx, element, offset, spacing, circular) {
const { fullCircles, startAngle, circumference } = element;
let endAngle = element.endAngle;
if (fullCircles) {
pathArc(ctx, element, offset, spacing, endAngle, circular);
for (let i2 = 0; i2 < fullCircles; ++i2) {
ctx.fill();
}
if (!isNaN(circumference)) {
endAngle = startAngle + (circumference % TAU || TAU);
}
}
pathArc(ctx, element, offset, spacing, endAngle, circular);
ctx.fill();
return endAngle;
}
function drawBorder(ctx, element, offset, spacing, circular) {
const { fullCircles, startAngle, circumference, options } = element;
const { borderWidth, borderJoinStyle, borderDash, borderDashOffset } = options;
const inner = options.borderAlign === "inner";
if (!borderWidth) {
return;
}
ctx.setLineDash(borderDash || []);
ctx.lineDashOffset = borderDashOffset;
if (inner) {
ctx.lineWidth = borderWidth * 2;
ctx.lineJoin = borderJoinStyle || "round";
} else {
ctx.lineWidth = borderWidth;
ctx.lineJoin = borderJoinStyle || "bevel";
}
let endAngle = element.endAngle;
if (fullCircles) {
pathArc(ctx, element, offset, spacing, endAngle, circular);
for (let i2 = 0; i2 < fullCircles; ++i2) {
ctx.stroke();
}
if (!isNaN(circumference)) {
endAngle = startAngle + (circumference % TAU || TAU);
}
}
if (inner) {
clipArc(ctx, element, endAngle);
}
if (!fullCircles) {
pathArc(ctx, element, offset, spacing, endAngle, circular);
ctx.stroke();
}
}
var ArcElement = class extends Element {
constructor(cfg) {
super();
__publicField(this, "circumference");
__publicField(this, "endAngle");
__publicField(this, "fullCircles");
__publicField(this, "innerRadius");
__publicField(this, "outerRadius");
__publicField(this, "pixelMargin");
__publicField(this, "startAngle");
this.options = void 0;
this.circumference = void 0;
this.startAngle = void 0;
this.endAngle = void 0;
this.innerRadius = void 0;
this.outerRadius = void 0;
this.pixelMargin = 0;
this.fullCircles = 0;
if (cfg) {
Object.assign(this, cfg);
}
}
inRange(chartX, chartY, useFinalPosition) {
const point = this.getProps([
"x",
"y"
], useFinalPosition);
const { angle, distance } = getAngleFromPoint(point, {
x: chartX,
y: chartY
});
const { startAngle, endAngle, innerRadius, outerRadius, circumference } = this.getProps([
"startAngle",
"endAngle",
"innerRadius",
"outerRadius",
"circumference"
], useFinalPosition);
const rAdjust = (this.options.spacing + this.options.borderWidth) / 2;
const _circumference = valueOrDefault(circumference, endAngle - startAngle);
const nonZeroBetween = _angleBetween(angle, startAngle, endAngle) && startAngle !== endAngle;
const betweenAngles = _circumference >= TAU || nonZeroBetween;
const withinRadius = _isBetween(distance, innerRadius + rAdjust, outerRadius + rAdjust);
return betweenAngles && withinRadius;
}
getCenterPoint(useFinalPosition) {
const { x: x2, y: y2, startAngle, endAngle, innerRadius, outerRadius } = this.getProps([
"x",
"y",
"startAngle",
"endAngle",
"innerRadius",
"outerRadius"
], useFinalPosition);
const { offset, spacing } = this.options;
const halfAngle = (startAngle + endAngle) / 2;
const halfRadius = (innerRadius + outerRadius + spacing + offset) / 2;
return {
x: x2 + Math.cos(halfAngle) * halfRadius,
y: y2 + Math.sin(halfAngle) * halfRadius
};
}
tooltipPosition(useFinalPosition) {
return this.getCenterPoint(useFinalPosition);
}
draw(ctx) {
const { options, circumference } = this;
const offset = (options.offset || 0) / 4;
const spacing = (options.spacing || 0) / 2;
const circular = options.circular;
this.pixelMargin = options.borderAlign === "inner" ? 0.33 : 0;
this.fullCircles = circumference > TAU ? Math.floor(circumference / TAU) : 0;
if (circumference === 0 || this.innerRadius < 0 || this.outerRadius < 0) {
return;
}
ctx.save();
const halfAngle = (this.startAngle + this.endAngle) / 2;
ctx.translate(Math.cos(halfAngle) * offset, Math.sin(halfAngle) * offset);
const fix = 1 - Math.sin(Math.min(PI, circumference || 0));
const radiusOffset = offset * fix;
ctx.fillStyle = options.backgroundColor;
ctx.strokeStyle = options.borderColor;
drawArc(ctx, this, radiusOffset, spacing, circular);
drawBorder(ctx, this, radiusOffset, spacing, circular);
ctx.restore();
}
};
__publicField(ArcElement, "id", "arc");
__publicField(ArcElement, "defaults", {
borderAlign: "center",
borderColor: "#fff",
borderDash: [],
borderDashOffset: 0,
borderJoinStyle: void 0,
borderRadius: 0,
borderWidth: 2,
offset: 0,
spacing: 0,
angle: void 0,
circular: true
});
__publicField(ArcElement, "defaultRoutes", {
backgroundColor: "backgroundColor"
});
__publicField(ArcElement, "descriptors", {
_scriptable: true,
_indexable: (name) => name !== "borderDash"
});
function getBarBounds(bar, useFinalPosition) {
const { x: x2, y: y2, base, width, height } = bar.getProps([
"x",
"y",
"base",
"width",
"height"
], useFinalPosition);
let left, right, top, bottom, half;
if (bar.horizontal) {
half = height / 2;
left = Math.min(x2, base);
right = Math.max(x2, base);
top = y2 - half;
bottom = y2 + half;
} else {
half = width / 2;
left = x2 - half;
right = x2 + half;
top = Math.min(y2, base);
bottom = Math.max(y2, base);
}
return {
left,
top,
right,
bottom
};
}
function skipOrLimit(skip2, value, min, max) {
return skip2 ? 0 : _limitValue(value, min, max);
}
function parseBorderWidth(bar, maxW, maxH) {
const value = bar.options.borderWidth;
const skip2 = bar.borderSkipped;
const o2 = toTRBL(value);
return {
t: skipOrLimit(skip2.top, o2.top, 0, maxH),
r: skipOrLimit(skip2.right, o2.right, 0, maxW),
b: skipOrLimit(skip2.bottom, o2.bottom, 0, maxH),
l: skipOrLimit(skip2.left, o2.left, 0, maxW)
};
}
function parseBorderRadius(bar, maxW, maxH) {
const { enableBorderRadius } = bar.getProps([
"enableBorderRadius"
]);
const value = bar.options.borderRadius;
const o2 = toTRBLCorners(value);
const maxR = Math.min(maxW, maxH);
const skip2 = bar.borderSkipped;
const enableBorder = enableBorderRadius || isObject(value);
return {
topLeft: skipOrLimit(!enableBorder || skip2.top || skip2.left, o2.topLeft, 0, maxR),
topRight: skipOrLimit(!enableBorder || skip2.top || skip2.right, o2.topRight, 0, maxR),
bottomLeft: skipOrLimit(!enableBorder || skip2.bottom || skip2.left, o2.bottomLeft, 0, maxR),
bottomRight: skipOrLimit(!enableBorder || skip2.bottom || skip2.right, o2.bottomRight, 0, maxR)
};
}
function boundingRects(bar) {
const bounds = getBarBounds(bar);
const width = bounds.right - bounds.left;
const height = bounds.bottom - bounds.top;
const border = parseBorderWidth(bar, width / 2, height / 2);
const radius = parseBorderRadius(bar, width / 2, height / 2);
return {
outer: {
x: bounds.left,
y: bounds.top,
w: width,
h: height,
radius
},
inner: {
x: bounds.left + border.l,
y: bounds.top + border.t,
w: width - border.l - border.r,
h: height - border.t - border.b,
radius: {
topLeft: Math.max(0, radius.topLeft - Math.max(border.t, border.l)),
topRight: Math.max(0, radius.topRight - Math.max(border.t, border.r)),
bottomLeft: Math.max(0, radius.bottomLeft - Math.max(border.b, border.l)),
bottomRight: Math.max(0, radius.bottomRight - Math.max(border.b, border.r))
}
}
};
}
function inRange(bar, x2, y2, useFinalPosition) {
const skipX = x2 === null;
const skipY = y2 === null;
const skipBoth = skipX && skipY;
const bounds = bar && !skipBoth && getBarBounds(bar, useFinalPosition);
return bounds && (skipX || _isBetween(x2, bounds.left, bounds.right)) && (skipY || _isBetween(y2, bounds.top, bounds.bottom));
}
function hasRadius(radius) {
return radius.topLeft || radius.topRight || radius.bottomLeft || radius.bottomRight;
}
function addNormalRectPath(ctx, rect) {
ctx.rect(rect.x, rect.y, rect.w, rect.h);
}
function inflateRect(rect, amount, refRect = {}) {
const x2 = rect.x !== refRect.x ? -amount : 0;
const y2 = rect.y !== refRect.y ? -amount : 0;
const w2 = (rect.x + rect.w !== refRect.x + refRect.w ? amount : 0) - x2;
const h6 = (rect.y + rect.h !== refRect.y + refRect.h ? amount : 0) - y2;
return {
x: rect.x + x2,
y: rect.y + y2,
w: rect.w + w2,
h: rect.h + h6,
radius: rect.radius
};
}
var BarElement = class extends Element {
constructor(cfg) {
super();
this.options = void 0;
this.horizontal = void 0;
this.base = void 0;
this.width = void 0;
this.height = void 0;
this.inflateAmount = void 0;
if (cfg) {
Object.assign(this, cfg);
}
}
draw(ctx) {
const { inflateAmount, options: { borderColor, backgroundColor } } = this;
const { inner, outer } = boundingRects(this);
const addRectPath = hasRadius(outer.radius) ? addRoundedRectPath : addNormalRectPath;
ctx.save();
if (outer.w !== inner.w || outer.h !== inner.h) {
ctx.beginPath();
addRectPath(ctx, inflateRect(outer, inflateAmount, inner));
ctx.clip();
addRectPath(ctx, inflateRect(inner, -inflateAmount, outer));
ctx.fillStyle = borderColor;
ctx.fill("evenodd");
}
ctx.beginPath();
addRectPath(ctx, inflateRect(inner, inflateAmount));
ctx.fillStyle = backgroundColor;
ctx.fill();
ctx.restore();
}
inRange(mouseX, mouseY, useFinalPosition) {
return inRange(this, mouseX, mouseY, useFinalPosition);
}
inXRange(mouseX, useFinalPosition) {
return inRange(this, mouseX, null, useFinalPosition);
}
inYRange(mouseY, useFinalPosition) {
return inRange(this, null, mouseY, useFinalPosition);
}
getCenterPoint(useFinalPosition) {
const { x: x2, y: y2, base, horizontal } = this.getProps([
"x",
"y",
"base",
"horizontal"
], useFinalPosition);
return {
x: horizontal ? (x2 + base) / 2 : x2,
y: horizontal ? y2 : (y2 + base) / 2
};
}
getRange(axis) {
return axis === "x" ? this.width / 2 : this.height / 2;
}
};
__publicField(BarElement, "id", "bar");
__publicField(BarElement, "defaults", {
borderSkipped: "start",
borderWidth: 0,
borderRadius: 0,
inflateAmount: "auto",
pointStyle: void 0
});
__publicField(BarElement, "defaultRoutes", {
backgroundColor: "backgroundColor",
borderColor: "borderColor"
});
var getBoxSize = (labelOpts, fontSize) => {
let { boxHeight = fontSize, boxWidth = fontSize } = labelOpts;
if (labelOpts.usePointStyle) {
boxHeight = Math.min(boxHeight, fontSize);
boxWidth = labelOpts.pointStyleWidth || Math.min(boxWidth, fontSize);
}
return {
boxWidth,
boxHeight,
itemHeight: Math.max(fontSize, boxHeight)
};
};
var itemsEqual = (a2, b2) => a2 !== null && b2 !== null && a2.datasetIndex === b2.datasetIndex && a2.index === b2.index;
var Legend = class extends Element {
constructor(config) {
super();
this._added = false;
this.legendHitBoxes = [];
this._hoveredItem = null;
this.doughnutMode = false;
this.chart = config.chart;
this.options = config.options;
this.ctx = config.ctx;
this.legendItems = void 0;
this.columnSizes = void 0;
this.lineWidths = void 0;
this.maxHeight = void 0;
this.maxWidth = void 0;
this.top = void 0;
this.bottom = void 0;
this.left = void 0;
this.right = void 0;
this.height = void 0;
this.width = void 0;
this._margins = void 0;
this.position = void 0;
this.weight = void 0;
this.fullSize = void 0;
}
update(maxWidth, maxHeight, margins) {
this.maxWidth = maxWidth;
this.maxHeight = maxHeight;
this._margins = margins;
this.setDimensions();
this.buildLabels();
this.fit();
}
setDimensions() {
if (this.isHorizontal()) {
this.width = this.maxWidth;
this.left = this._margins.left;
this.right = this.width;
} else {
this.height = this.maxHeight;
this.top = this._margins.top;
this.bottom = this.height;
}
}
buildLabels() {
const labelOpts = this.options.labels || {};
let legendItems = callback(labelOpts.generateLabels, [
this.chart
], this) || [];
if (labelOpts.filter) {
legendItems = legendItems.filter((item) => labelOpts.filter(item, this.chart.data));
}
if (labelOpts.sort) {
legendItems = legendItems.sort((a2, b2) => labelOpts.sort(a2, b2, this.chart.data));
}
if (this.options.reverse) {
legendItems.reverse();
}
this.legendItems = legendItems;
}
fit() {
const { options, ctx } = this;
if (!options.display) {
this.width = this.height = 0;
return;
}
const labelOpts = options.labels;
const labelFont = toFont(labelOpts.font);
const fontSize = labelFont.size;
const titleHeight = this._computeTitleHeight();
const { boxWidth, itemHeight } = getBoxSize(labelOpts, fontSize);
let width, height;
ctx.font = labelFont.string;
if (this.isHorizontal()) {
width = this.maxWidth;
height = this._fitRows(titleHeight, fontSize, boxWidth, itemHeight) + 10;
} else {
height = this.maxHeight;
width = this._fitCols(titleHeight, labelFont, boxWidth, itemHeight) + 10;
}
this.width = Math.min(width, options.maxWidth || this.maxWidth);
this.height = Math.min(height, options.maxHeight || this.maxHeight);
}
_fitRows(titleHeight, fontSize, boxWidth, itemHeight) {
const { ctx, maxWidth, options: { labels: { padding } } } = this;
const hitboxes = this.legendHitBoxes = [];
const lineWidths = this.lineWidths = [
0
];
const lineHeight = itemHeight + padding;
let totalHeight = titleHeight;
ctx.textAlign = "left";
ctx.textBaseline = "middle";
let row = -1;
let top = -lineHeight;
this.legendItems.forEach((legendItem, i2) => {
const itemWidth = boxWidth + fontSize / 2 + ctx.measureText(legendItem.text).width;
if (i2 === 0 || lineWidths[lineWidths.length - 1] + itemWidth + 2 * padding > maxWidth) {
totalHeight += lineHeight;
lineWidths[lineWidths.length - (i2 > 0 ? 0 : 1)] = 0;
top += lineHeight;
row++;
}
hitboxes[i2] = {
left: 0,
top,
row,
width: itemWidth,
height: itemHeight
};
lineWidths[lineWidths.length - 1] += itemWidth + padding;
});
return totalHeight;
}
_fitCols(titleHeight, labelFont, boxWidth, _itemHeight) {
const { ctx, maxHeight, options: { labels: { padding } } } = this;
const hitboxes = this.legendHitBoxes = [];
const columnSizes = this.columnSizes = [];
const heightLimit = maxHeight - titleHeight;
let totalWidth = padding;
let currentColWidth = 0;
let currentColHeight = 0;
let left = 0;
let col = 0;
this.legendItems.forEach((legendItem, i2) => {
const { itemWidth, itemHeight } = calculateItemSize(boxWidth, labelFont, ctx, legendItem, _itemHeight);
if (i2 > 0 && currentColHeight + itemHeight + 2 * padding > heightLimit) {
totalWidth += currentColWidth + padding;
columnSizes.push({
width: currentColWidth,
height: currentColHeight
});
left += currentColWidth + padding;
col++;
currentColWidth = currentColHeight = 0;
}
hitboxes[i2] = {
left,
top: currentColHeight,
col,
width: itemWidth,
height: itemHeight
};
currentColWidth = Math.max(currentColWidth, itemWidth);
currentColHeight += itemHeight + padding;
});
totalWidth += currentColWidth;
columnSizes.push({
width: currentColWidth,
height: currentColHeight
});
return totalWidth;
}
adjustHitBoxes() {
if (!this.options.display) {
return;
}
const titleHeight = this._computeTitleHeight();
const { legendHitBoxes: hitboxes, options: { align, labels: { padding }, rtl } } = this;
const rtlHelper = getRtlAdapter(rtl, this.left, this.width);
if (this.isHorizontal()) {
let row = 0;
let left = _alignStartEnd(align, this.left + padding, this.right - this.lineWidths[row]);
for (const hitbox of hitboxes) {
if (row !== hitbox.row) {
row = hitbox.row;
left = _alignStartEnd(align, this.left + padding, this.right - this.lineWidths[row]);
}
hitbox.top += this.top + titleHeight + padding;
hitbox.left = rtlHelper.leftForLtr(rtlHelper.x(left), hitbox.width);
left += hitbox.width + padding;
}
} else {
let col = 0;
let top = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - this.columnSizes[col].height);
for (const hitbox of hitboxes) {
if (hitbox.col !== col) {
col = hitbox.col;
top = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - this.columnSizes[col].height);
}
hitbox.top = top;
hitbox.left += this.left + padding;
hitbox.left = rtlHelper.leftForLtr(rtlHelper.x(hitbox.left), hitbox.width);
top += hitbox.height + padding;
}
}
}
isHorizontal() {
return this.options.position === "top" || this.options.position === "bottom";
}
draw() {
if (this.options.display) {
const ctx = this.ctx;
clipArea(ctx, this);
this._draw();
unclipArea(ctx);
}
}
_draw() {
const { options: opts, columnSizes, lineWidths, ctx } = this;
const { align, labels: labelOpts } = opts;
const defaultColor = defaults2.color;
const rtlHelper = getRtlAdapter(opts.rtl, this.left, this.width);
const labelFont = toFont(labelOpts.font);
const { padding } = labelOpts;
const fontSize = labelFont.size;
const halfFontSize = fontSize / 2;
let cursor;
this.drawTitle();
ctx.textAlign = rtlHelper.textAlign("left");
ctx.textBaseline = "middle";
ctx.lineWidth = 0.5;
ctx.font = labelFont.string;
const { boxWidth, boxHeight, itemHeight } = getBoxSize(labelOpts, fontSize);
const drawLegendBox = function(x2, y2, legendItem) {
if (isNaN(boxWidth) || boxWidth <= 0 || isNaN(boxHeight) || boxHeight < 0) {
return;
}
ctx.save();
const lineWidth = valueOrDefault(legendItem.lineWidth, 1);
ctx.fillStyle = valueOrDefault(legendItem.fillStyle, defaultColor);
ctx.lineCap = valueOrDefault(legendItem.lineCap, "butt");
ctx.lineDashOffset = valueOrDefault(legendItem.lineDashOffset, 0);
ctx.lineJoin = valueOrDefault(legendItem.lineJoin, "miter");
ctx.lineWidth = lineWidth;
ctx.strokeStyle = valueOrDefault(legendItem.strokeStyle, defaultColor);
ctx.setLineDash(valueOrDefault(legendItem.lineDash, []));
if (labelOpts.usePointStyle) {
const drawOptions = {
radius: boxHeight * Math.SQRT2 / 2,
pointStyle: legendItem.pointStyle,
rotation: legendItem.rotation,
borderWidth: lineWidth
};
const centerX = rtlHelper.xPlus(x2, boxWidth / 2);
const centerY = y2 + halfFontSize;
drawPointLegend(ctx, drawOptions, centerX, centerY, labelOpts.pointStyleWidth && boxWidth);
} else {
const yBoxTop = y2 + Math.max((fontSize - boxHeight) / 2, 0);
const xBoxLeft = rtlHelper.leftForLtr(x2, boxWidth);
const borderRadius = toTRBLCorners(legendItem.borderRadius);
ctx.beginPath();
if (Object.values(borderRadius).some((v2) => v2 !== 0)) {
addRoundedRectPath(ctx, {
x: xBoxLeft,
y: yBoxTop,
w: boxWidth,
h: boxHeight,
radius: borderRadius
});
} else {
ctx.rect(xBoxLeft, yBoxTop, boxWidth, boxHeight);
}
ctx.fill();
if (lineWidth !== 0) {
ctx.stroke();
}
}
ctx.restore();
};
const fillText = function(x2, y2, legendItem) {
renderText(ctx, legendItem.text, x2, y2 + itemHeight / 2, labelFont, {
strikethrough: legendItem.hidden,
textAlign: rtlHelper.textAlign(legendItem.textAlign)
});
};
const isHorizontal = this.isHorizontal();
const titleHeight = this._computeTitleHeight();
if (isHorizontal) {
cursor = {
x: _alignStartEnd(align, this.left + padding, this.right - lineWidths[0]),
y: this.top + padding + titleHeight,
line: 0
};
} else {
cursor = {
x: this.left + padding,
y: _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - columnSizes[0].height),
line: 0
};
}
overrideTextDirection(this.ctx, opts.textDirection);
const lineHeight = itemHeight + padding;
this.legendItems.forEach((legendItem, i2) => {
ctx.strokeStyle = legendItem.fontColor;
ctx.fillStyle = legendItem.fontColor;
const textWidth = ctx.measureText(legendItem.text).width;
const textAlign = rtlHelper.textAlign(legendItem.textAlign || (legendItem.textAlign = labelOpts.textAlign));
const width = boxWidth + halfFontSize + textWidth;
let x2 = cursor.x;
let y2 = cursor.y;
rtlHelper.setWidth(this.width);
if (isHorizontal) {
if (i2 > 0 && x2 + width + padding > this.right) {
y2 = cursor.y += lineHeight;
cursor.line++;
x2 = cursor.x = _alignStartEnd(align, this.left + padding, this.right - lineWidths[cursor.line]);
}
} else if (i2 > 0 && y2 + lineHeight > this.bottom) {
x2 = cursor.x = x2 + columnSizes[cursor.line].width + padding;
cursor.line++;
y2 = cursor.y = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - columnSizes[cursor.line].height);
}
const realX = rtlHelper.x(x2);
drawLegendBox(realX, y2, legendItem);
x2 = _textX(textAlign, x2 + boxWidth + halfFontSize, isHorizontal ? x2 + width : this.right, opts.rtl);
fillText(rtlHelper.x(x2), y2, legendItem);
if (isHorizontal) {
cursor.x += width + padding;
} else if (typeof legendItem.text !== "string") {
const fontLineHeight = labelFont.lineHeight;
cursor.y += calculateLegendItemHeight(legendItem, fontLineHeight) + padding;
} else {
cursor.y += lineHeight;
}
});
restoreTextDirection(this.ctx, opts.textDirection);
}
drawTitle() {
const opts = this.options;
const titleOpts = opts.title;
const titleFont = toFont(titleOpts.font);
const titlePadding = toPadding(titleOpts.padding);
if (!titleOpts.display) {
return;
}
const rtlHelper = getRtlAdapter(opts.rtl, this.left, this.width);
const ctx = this.ctx;
const position = titleOpts.position;
const halfFontSize = titleFont.size / 2;
const topPaddingPlusHalfFontSize = titlePadding.top + halfFontSize;
let y2;
let left = this.left;
let maxWidth = this.width;
if (this.isHorizontal()) {
maxWidth = Math.max(...this.lineWidths);
y2 = this.top + topPaddingPlusHalfFontSize;
left = _alignStartEnd(opts.align, left, this.right - maxWidth);
} else {
const maxHeight = this.columnSizes.reduce((acc, size) => Math.max(acc, size.height), 0);
y2 = topPaddingPlusHalfFontSize + _alignStartEnd(opts.align, this.top, this.bottom - maxHeight - opts.labels.padding - this._computeTitleHeight());
}
const x2 = _alignStartEnd(position, left, left + maxWidth);
ctx.textAlign = rtlHelper.textAlign(_toLeftRightCenter(position));
ctx.textBaseline = "middle";
ctx.strokeStyle = titleOpts.color;
ctx.fillStyle = titleOpts.color;
ctx.font = titleFont.string;
renderText(ctx, titleOpts.text, x2, y2, titleFont);
}
_computeTitleHeight() {
const titleOpts = this.options.title;
const titleFont = toFont(titleOpts.font);
const titlePadding = toPadding(titleOpts.padding);
return titleOpts.display ? titleFont.lineHeight + titlePadding.height : 0;
}
_getLegendItemAt(x2, y2) {
let i2, hitBox, lh;
if (_isBetween(x2, this.left, this.right) && _isBetween(y2, this.top, this.bottom)) {
lh = this.legendHitBoxes;
for (i2 = 0; i2 < lh.length; ++i2) {
hitBox = lh[i2];
if (_isBetween(x2, hitBox.left, hitBox.left + hitBox.width) && _isBetween(y2, hitBox.top, hitBox.top + hitBox.height)) {
return this.legendItems[i2];
}
}
}
return null;
}
handleEvent(e2) {
const opts = this.options;
if (!isListened(e2.type, opts)) {
return;
}
const hoveredItem = this._getLegendItemAt(e2.x, e2.y);
if (e2.type === "mousemove" || e2.type === "mouseout") {
const previous = this._hoveredItem;
const sameItem = itemsEqual(previous, hoveredItem);
if (previous && !sameItem) {
callback(opts.onLeave, [
e2,
previous,
this
], this);
}
this._hoveredItem = hoveredItem;
if (hoveredItem && !sameItem) {
callback(opts.onHover, [
e2,
hoveredItem,
this
], this);
}
} else if (hoveredItem) {
callback(opts.onClick, [
e2,
hoveredItem,
this
], this);
}
}
};
function calculateItemSize(boxWidth, labelFont, ctx, legendItem, _itemHeight) {
const itemWidth = calculateItemWidth(legendItem, boxWidth, labelFont, ctx);
const itemHeight = calculateItemHeight(_itemHeight, legendItem, labelFont.lineHeight);
return {
itemWidth,
itemHeight
};
}
function calculateItemWidth(legendItem, boxWidth, labelFont, ctx) {
let legendItemText = legendItem.text;
if (legendItemText && typeof legendItemText !== "string") {
legendItemText = legendItemText.reduce((a2, b2) => a2.length > b2.length ? a2 : b2);
}
return boxWidth + labelFont.size / 2 + ctx.measureText(legendItemText).width;
}
function calculateItemHeight(_itemHeight, legendItem, fontLineHeight) {
let itemHeight = _itemHeight;
if (typeof legendItem.text !== "string") {
itemHeight = calculateLegendItemHeight(legendItem, fontLineHeight);
}
return itemHeight;
}
function calculateLegendItemHeight(legendItem, fontLineHeight) {
const labelHeight = legendItem.text ? legendItem.text.length : 0;
return fontLineHeight * labelHeight;
}
function isListened(type, opts) {
if ((type === "mousemove" || type === "mouseout") && (opts.onHover || opts.onLeave)) {
return true;
}
if (opts.onClick && (type === "click" || type === "mouseup")) {
return true;
}
return false;
}
var plugin_legend = {
id: "legend",
_element: Legend,
start(chart, _args, options) {
const legend = chart.legend = new Legend({
ctx: chart.ctx,
options,
chart
});
layouts.configure(chart, legend, options);
layouts.addBox(chart, legend);
},
stop(chart) {
layouts.removeBox(chart, chart.legend);
delete chart.legend;
},
beforeUpdate(chart, _args, options) {
const legend = chart.legend;
layouts.configure(chart, legend, options);
legend.options = options;
},
afterUpdate(chart) {
const legend = chart.legend;
legend.buildLabels();
legend.adjustHitBoxes();
},
afterEvent(chart, args) {
if (!args.replay) {
chart.legend.handleEvent(args.event);
}
},
defaults: {
display: true,
position: "top",
align: "center",
fullSize: true,
reverse: false,
weight: 1e3,
onClick(e2, legendItem, legend) {
const index = legendItem.datasetIndex;
const ci = legend.chart;
if (ci.isDatasetVisible(index)) {
ci.hide(index);
legendItem.hidden = true;
} else {
ci.show(index);
legendItem.hidden = false;
}
},
onHover: null,
onLeave: null,
labels: {
color: (ctx) => ctx.chart.options.color,
boxWidth: 40,
padding: 10,
generateLabels(chart) {
const datasets = chart.data.datasets;
const { labels: { usePointStyle, pointStyle, textAlign, color: color2, useBorderRadius, borderRadius } } = chart.legend.options;
return chart._getSortedDatasetMetas().map((meta) => {
const style = meta.controller.getStyle(usePointStyle ? 0 : void 0);
const borderWidth = toPadding(style.borderWidth);
return {
text: datasets[meta.index].label,
fillStyle: style.backgroundColor,
fontColor: color2,
hidden: !meta.visible,
lineCap: style.borderCapStyle,
lineDash: style.borderDash,
lineDashOffset: style.borderDashOffset,
lineJoin: style.borderJoinStyle,
lineWidth: (borderWidth.width + borderWidth.height) / 4,
strokeStyle: style.borderColor,
pointStyle: pointStyle || style.pointStyle,
rotation: style.rotation,
textAlign: textAlign || style.textAlign,
borderRadius: useBorderRadius && (borderRadius || style.borderRadius),
datasetIndex: meta.index
};
}, this);
}
},
title: {
color: (ctx) => ctx.chart.options.color,
display: false,
position: "center",
text: ""
}
},
descriptors: {
_scriptable: (name) => !name.startsWith("on"),
labels: {
_scriptable: (name) => ![
"generateLabels",
"filter",
"sort"
].includes(name)
}
}
};
var Title = class extends Element {
constructor(config) {
super();
this.chart = config.chart;
this.options = config.options;
this.ctx = config.ctx;
this._padding = void 0;
this.top = void 0;
this.bottom = void 0;
this.left = void 0;
this.right = void 0;
this.width = void 0;
this.height = void 0;
this.position = void 0;
this.weight = void 0;
this.fullSize = void 0;
}
update(maxWidth, maxHeight) {
const opts = this.options;
this.left = 0;
this.top = 0;
if (!opts.display) {
this.width = this.height = this.right = this.bottom = 0;
return;
}
this.width = this.right = maxWidth;
this.height = this.bottom = maxHeight;
const lineCount = isArray(opts.text) ? opts.text.length : 1;
this._padding = toPadding(opts.padding);
const textSize = lineCount * toFont(opts.font).lineHeight + this._padding.height;
if (this.isHorizontal()) {
this.height = textSize;
} else {
this.width = textSize;
}
}
isHorizontal() {
const pos = this.options.position;
return pos === "top" || pos === "bottom";
}
_drawArgs(offset) {
const { top, left, bottom, right, options } = this;
const align = options.align;
let rotation = 0;
let maxWidth, titleX, titleY;
if (this.isHorizontal()) {
titleX = _alignStartEnd(align, left, right);
titleY = top + offset;
maxWidth = right - left;
} else {
if (options.position === "left") {
titleX = left + offset;
titleY = _alignStartEnd(align, bottom, top);
rotation = PI * -0.5;
} else {
titleX = right - offset;
titleY = _alignStartEnd(align, top, bottom);
rotation = PI * 0.5;
}
maxWidth = bottom - top;
}
return {
titleX,
titleY,
maxWidth,
rotation
};
}
draw() {
const ctx = this.ctx;
const opts = this.options;
if (!opts.display) {
return;
}
const fontOpts = toFont(opts.font);
const lineHeight = fontOpts.lineHeight;
const offset = lineHeight / 2 + this._padding.top;
const { titleX, titleY, maxWidth, rotation } = this._drawArgs(offset);
renderText(ctx, opts.text, 0, 0, fontOpts, {
color: opts.color,
maxWidth,
rotation,
textAlign: _toLeftRightCenter(opts.align),
textBaseline: "middle",
translation: [
titleX,
titleY
]
});
}
};
function createTitle(chart, titleOpts) {
const title = new Title({
ctx: chart.ctx,
options: titleOpts,
chart
});
layouts.configure(chart, title, titleOpts);
layouts.addBox(chart, title);
chart.titleBlock = title;
}
var plugin_title = {
id: "title",
_element: Title,
start(chart, _args, options) {
createTitle(chart, options);
},
stop(chart) {
const titleBlock = chart.titleBlock;
layouts.removeBox(chart, titleBlock);
delete chart.titleBlock;
},
beforeUpdate(chart, _args, options) {
const title = chart.titleBlock;
layouts.configure(chart, title, options);
title.options = options;
},
defaults: {
align: "center",
display: false,
font: {
weight: "bold"
},
fullSize: true,
padding: 10,
position: "top",
text: "",
weight: 2e3
},
defaultRoutes: {
color: "color"
},
descriptors: {
_scriptable: true,
_indexable: false
}
};
var map2 = /* @__PURE__ */ new WeakMap();
var plugin_subtitle = {
id: "subtitle",
start(chart, _args, options) {
const title = new Title({
ctx: chart.ctx,
options,
chart
});
layouts.configure(chart, title, options);
layouts.addBox(chart, title);
map2.set(chart, title);
},
stop(chart) {
layouts.removeBox(chart, map2.get(chart));
map2.delete(chart);
},
beforeUpdate(chart, _args, options) {
const title = map2.get(chart);
layouts.configure(chart, title, options);
title.options = options;
},
defaults: {
align: "center",
display: false,
font: {
weight: "normal"
},
fullSize: true,
padding: 0,
position: "top",
text: "",
weight: 1500
},
defaultRoutes: {
color: "color"
},
descriptors: {
_scriptable: true,
_indexable: false
}
};
var positioners = {
average(items) {
if (!items.length) {
return false;
}
let i2, len;
let xSet = /* @__PURE__ */ new Set();
let y2 = 0;
let count = 0;
for (i2 = 0, len = items.length; i2 < len; ++i2) {
const el = items[i2].element;
if (el && el.hasValue()) {
const pos = el.tooltipPosition();
xSet.add(pos.x);
y2 += pos.y;
++count;
}
}
if (count === 0 || xSet.size === 0) {
return false;
}
const xAverage = [
...xSet
].reduce((a2, b2) => a2 + b2) / xSet.size;
return {
x: xAverage,
y: y2 / count
};
},
nearest(items, eventPosition) {
if (!items.length) {
return false;
}
let x2 = eventPosition.x;
let y2 = eventPosition.y;
let minDistance = Number.POSITIVE_INFINITY;
let i2, len, nearestElement;
for (i2 = 0, len = items.length; i2 < len; ++i2) {
const el = items[i2].element;
if (el && el.hasValue()) {
const center = el.getCenterPoint();
const d2 = distanceBetweenPoints(eventPosition, center);
if (d2 < minDistance) {
minDistance = d2;
nearestElement = el;
}
}
}
if (nearestElement) {
const tp = nearestElement.tooltipPosition();
x2 = tp.x;
y2 = tp.y;
}
return {
x: x2,
y: y2
};
}
};
function pushOrConcat(base, toPush) {
if (toPush) {
if (isArray(toPush)) {
Array.prototype.push.apply(base, toPush);
} else {
base.push(toPush);
}
}
return base;
}
function splitNewlines(str) {
if ((typeof str === "string" || str instanceof String) && str.indexOf("\n") > -1) {
return str.split("\n");
}
return str;
}
function createTooltipItem(chart, item) {
const { element, datasetIndex, index } = item;
const controller = chart.getDatasetMeta(datasetIndex).controller;
const { label, value } = controller.getLabelAndValue(index);
return {
chart,
label,
parsed: controller.getParsed(index),
raw: chart.data.datasets[datasetIndex].data[index],
formattedValue: value,
dataset: controller.getDataset(),
dataIndex: index,
datasetIndex,
element
};
}
function getTooltipSize(tooltip, options) {
const ctx = tooltip.chart.ctx;
const { body, footer, title } = tooltip;
const { boxWidth, boxHeight } = options;
const bodyFont = toFont(options.bodyFont);
const titleFont = toFont(options.titleFont);
const footerFont = toFont(options.footerFont);
const titleLineCount = title.length;
const footerLineCount = footer.length;
const bodyLineItemCount = body.length;
const padding = toPadding(options.padding);
let height = padding.height;
let width = 0;
let combinedBodyLength = body.reduce((count, bodyItem) => count + bodyItem.before.length + bodyItem.lines.length + bodyItem.after.length, 0);
combinedBodyLength += tooltip.beforeBody.length + tooltip.afterBody.length;
if (titleLineCount) {
height += titleLineCount * titleFont.lineHeight + (titleLineCount - 1) * options.titleSpacing + options.titleMarginBottom;
}
if (combinedBodyLength) {
const bodyLineHeight = options.displayColors ? Math.max(boxHeight, bodyFont.lineHeight) : bodyFont.lineHeight;
height += bodyLineItemCount * bodyLineHeight + (combinedBodyLength - bodyLineItemCount) * bodyFont.lineHeight + (combinedBodyLength - 1) * options.bodySpacing;
}
if (footerLineCount) {
height += options.footerMarginTop + footerLineCount * footerFont.lineHeight + (footerLineCount - 1) * options.footerSpacing;
}
let widthPadding = 0;
const maxLineWidth = function(line) {
width = Math.max(width, ctx.measureText(line).width + widthPadding);
};
ctx.save();
ctx.font = titleFont.string;
each(tooltip.title, maxLineWidth);
ctx.font = bodyFont.string;
each(tooltip.beforeBody.concat(tooltip.afterBody), maxLineWidth);
widthPadding = options.displayColors ? boxWidth + 2 + options.boxPadding : 0;
each(body, (bodyItem) => {
each(bodyItem.before, maxLineWidth);
each(bodyItem.lines, maxLineWidth);
each(bodyItem.after, maxLineWidth);
});
widthPadding = 0;
ctx.font = footerFont.string;
each(tooltip.footer, maxLineWidth);
ctx.restore();
width += padding.width;
return {
width,
height
};
}
function determineYAlign(chart, size) {
const { y: y2, height } = size;
if (y2 < height / 2) {
return "top";
} else if (y2 > chart.height - height / 2) {
return "bottom";
}
return "center";
}
function doesNotFitWithAlign(xAlign, chart, options, size) {
const { x: x2, width } = size;
const caret = options.caretSize + options.caretPadding;
if (xAlign === "left" && x2 + width + caret > chart.width) {
return true;
}
if (xAlign === "right" && x2 - width - caret < 0) {
return true;
}
}
function determineXAlign(chart, options, size, yAlign) {
const { x: x2, width } = size;
const { width: chartWidth, chartArea: { left, right } } = chart;
let xAlign = "center";
if (yAlign === "center") {
xAlign = x2 <= (left + right) / 2 ? "left" : "right";
} else if (x2 <= width / 2) {
xAlign = "left";
} else if (x2 >= chartWidth - width / 2) {
xAlign = "right";
}
if (doesNotFitWithAlign(xAlign, chart, options, size)) {
xAlign = "center";
}
return xAlign;
}
function determineAlignment(chart, options, size) {
const yAlign = size.yAlign || options.yAlign || determineYAlign(chart, size);
return {
xAlign: size.xAlign || options.xAlign || determineXAlign(chart, options, size, yAlign),
yAlign
};
}
function alignX(size, xAlign) {
let { x: x2, width } = size;
if (xAlign === "right") {
x2 -= width;
} else if (xAlign === "center") {
x2 -= width / 2;
}
return x2;
}
function alignY(size, yAlign, paddingAndSize) {
let { y: y2, height } = size;
if (yAlign === "top") {
y2 += paddingAndSize;
} else if (yAlign === "bottom") {
y2 -= height + paddingAndSize;
} else {
y2 -= height / 2;
}
return y2;
}
function getBackgroundPoint(options, size, alignment, chart) {
const { caretSize, caretPadding, cornerRadius } = options;
const { xAlign, yAlign } = alignment;
const paddingAndSize = caretSize + caretPadding;
const { topLeft, topRight, bottomLeft, bottomRight } = toTRBLCorners(cornerRadius);
let x2 = alignX(size, xAlign);
const y2 = alignY(size, yAlign, paddingAndSize);
if (yAlign === "center") {
if (xAlign === "left") {
x2 += paddingAndSize;
} else if (xAlign === "right") {
x2 -= paddingAndSize;
}
} else if (xAlign === "left") {
x2 -= Math.max(topLeft, bottomLeft) + caretSize;
} else if (xAlign === "right") {
x2 += Math.max(topRight, bottomRight) + caretSize;
}
return {
x: _limitValue(x2, 0, chart.width - size.width),
y: _limitValue(y2, 0, chart.height - size.height)
};
}
function getAlignedX(tooltip, align, options) {
const padding = toPadding(options.padding);
return align === "center" ? tooltip.x + tooltip.width / 2 : align === "right" ? tooltip.x + tooltip.width - padding.right : tooltip.x + padding.left;
}
function getBeforeAfterBodyLines(callback2) {
return pushOrConcat([], splitNewlines(callback2));
}
function createTooltipContext(parent, tooltip, tooltipItems) {
return createContext(parent, {
tooltip,
tooltipItems,
type: "tooltip"
});
}
function overrideCallbacks(callbacks, context) {
const override = context && context.dataset && context.dataset.tooltip && context.dataset.tooltip.callbacks;
return override ? callbacks.override(override) : callbacks;
}
var defaultCallbacks = {
beforeTitle: noop,
title(tooltipItems) {
if (tooltipItems.length > 0) {
const item = tooltipItems[0];
const labels = item.chart.data.labels;
const labelCount = labels ? labels.length : 0;
if (this && this.options && this.options.mode === "dataset") {
return item.dataset.label || "";
} else if (item.label) {
return item.label;
} else if (labelCount > 0 && item.dataIndex < labelCount) {
return labels[item.dataIndex];
}
}
return "";
},
afterTitle: noop,
beforeBody: noop,
beforeLabel: noop,
label(tooltipItem) {
if (this && this.options && this.options.mode === "dataset") {
return tooltipItem.label + ": " + tooltipItem.formattedValue || tooltipItem.formattedValue;
}
let label = tooltipItem.dataset.label || "";
if (label) {
label += ": ";
}
const value = tooltipItem.formattedValue;
if (!isNullOrUndef(value)) {
label += value;
}
return label;
},
labelColor(tooltipItem) {
const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex);
const options = meta.controller.getStyle(tooltipItem.dataIndex);
return {
borderColor: options.borderColor,
backgroundColor: options.backgroundColor,
borderWidth: options.borderWidth,
borderDash: options.borderDash,
borderDashOffset: options.borderDashOffset,
borderRadius: 0
};
},
labelTextColor() {
return this.options.bodyColor;
},
labelPointStyle(tooltipItem) {
const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex);
const options = meta.controller.getStyle(tooltipItem.dataIndex);
return {
pointStyle: options.pointStyle,
rotation: options.rotation
};
},
afterLabel: noop,
afterBody: noop,
beforeFooter: noop,
footer: noop,
afterFooter: noop
};
function invokeCallbackWithFallback(callbacks, name, ctx, arg) {
const result = callbacks[name].call(ctx, arg);
if (typeof result === "undefined") {
return defaultCallbacks[name].call(ctx, arg);
}
return result;
}
var Tooltip = class extends Element {
constructor(config) {
super();
this.opacity = 0;
this._active = [];
this._eventPosition = void 0;
this._size = void 0;
this._cachedAnimations = void 0;
this._tooltipItems = [];
this.$animations = void 0;
this.$context = void 0;
this.chart = config.chart;
this.options = config.options;
this.dataPoints = void 0;
this.title = void 0;
this.beforeBody = void 0;
this.body = void 0;
this.afterBody = void 0;
this.footer = void 0;
this.xAlign = void 0;
this.yAlign = void 0;
this.x = void 0;
this.y = void 0;
this.height = void 0;
this.width = void 0;
this.caretX = void 0;
this.caretY = void 0;
this.labelColors = void 0;
this.labelPointStyles = void 0;
this.labelTextColors = void 0;
}
initialize(options) {
this.options = options;
this._cachedAnimations = void 0;
this.$context = void 0;
}
_resolveAnimations() {
const cached = this._cachedAnimations;
if (cached) {
return cached;
}
const chart = this.chart;
const options = this.options.setContext(this.getContext());
const opts = options.enabled && chart.options.animation && options.animations;
const animations = new Animations(this.chart, opts);
if (opts._cacheable) {
this._cachedAnimations = Object.freeze(animations);
}
return animations;
}
getContext() {
return this.$context || (this.$context = createTooltipContext(this.chart.getContext(), this, this._tooltipItems));
}
getTitle(context, options) {
const { callbacks } = options;
const beforeTitle = invokeCallbackWithFallback(callbacks, "beforeTitle", this, context);
const title = invokeCallbackWithFallback(callbacks, "title", this, context);
const afterTitle = invokeCallbackWithFallback(callbacks, "afterTitle", this, context);
let lines = [];
lines = pushOrConcat(lines, splitNewlines(beforeTitle));
lines = pushOrConcat(lines, splitNewlines(title));
lines = pushOrConcat(lines, splitNewlines(afterTitle));
return lines;
}
getBeforeBody(tooltipItems, options) {
return getBeforeAfterBodyLines(invokeCallbackWithFallback(options.callbacks, "beforeBody", this, tooltipItems));
}
getBody(tooltipItems, options) {
const { callbacks } = options;
const bodyItems = [];
each(tooltipItems, (context) => {
const bodyItem = {
before: [],
lines: [],
after: []
};
const scoped = overrideCallbacks(callbacks, context);
pushOrConcat(bodyItem.before, splitNewlines(invokeCallbackWithFallback(scoped, "beforeLabel", this, context)));
pushOrConcat(bodyItem.lines, invokeCallbackWithFallback(scoped, "label", this, context));
pushOrConcat(bodyItem.after, splitNewlines(invokeCallbackWithFallback(scoped, "afterLabel", this, context)));
bodyItems.push(bodyItem);
});
return bodyItems;
}
getAfterBody(tooltipItems, options) {
return getBeforeAfterBodyLines(invokeCallbackWithFallback(options.callbacks, "afterBody", this, tooltipItems));
}
getFooter(tooltipItems, options) {
const { callbacks } = options;
const beforeFooter = invokeCallbackWithFallback(callbacks, "beforeFooter", this, tooltipItems);
const footer = invokeCallbackWithFallback(callbacks, "footer", this, tooltipItems);
const afterFooter = invokeCallbackWithFallback(callbacks, "afterFooter", this, tooltipItems);
let lines = [];
lines = pushOrConcat(lines, splitNewlines(beforeFooter));
lines = pushOrConcat(lines, splitNewlines(footer));
lines = pushOrConcat(lines, splitNewlines(afterFooter));
return lines;
}
_createItems(options) {
const active = this._active;
const data = this.chart.data;
const labelColors = [];
const labelPointStyles = [];
const labelTextColors = [];
let tooltipItems = [];
let i2, len;
for (i2 = 0, len = active.length; i2 < len; ++i2) {
tooltipItems.push(createTooltipItem(this.chart, active[i2]));
}
if (options.filter) {
tooltipItems = tooltipItems.filter((element, index, array) => options.filter(element, index, array, data));
}
if (options.itemSort) {
tooltipItems = tooltipItems.sort((a2, b2) => options.itemSort(a2, b2, data));
}
each(tooltipItems, (context) => {
const scoped = overrideCallbacks(options.callbacks, context);
labelColors.push(invokeCallbackWithFallback(scoped, "labelColor", this, context));
labelPointStyles.push(invokeCallbackWithFallback(scoped, "labelPointStyle", this, context));
labelTextColors.push(invokeCallbackWithFallback(scoped, "labelTextColor", this, context));
});
this.labelColors = labelColors;
this.labelPointStyles = labelPointStyles;
this.labelTextColors = labelTextColors;
this.dataPoints = tooltipItems;
return tooltipItems;
}
update(changed, replay) {
const options = this.options.setContext(this.getContext());
const active = this._active;
let properties;
let tooltipItems = [];
if (!active.length) {
if (this.opacity !== 0) {
properties = {
opacity: 0
};
}
} else {
const position = positioners[options.position].call(this, active, this._eventPosition);
tooltipItems = this._createItems(options);
this.title = this.getTitle(tooltipItems, options);
this.beforeBody = this.getBeforeBody(tooltipItems, options);
this.body = this.getBody(tooltipItems, options);
this.afterBody = this.getAfterBody(tooltipItems, options);
this.footer = this.getFooter(tooltipItems, options);
const size = this._size = getTooltipSize(this, options);
const positionAndSize = Object.assign({}, position, size);
const alignment = determineAlignment(this.chart, options, positionAndSize);
const backgroundPoint = getBackgroundPoint(options, positionAndSize, alignment, this.chart);
this.xAlign = alignment.xAlign;
this.yAlign = alignment.yAlign;
properties = {
opacity: 1,
x: backgroundPoint.x,
y: backgroundPoint.y,
width: size.width,
height: size.height,
caretX: position.x,
caretY: position.y
};
}
this._tooltipItems = tooltipItems;
this.$context = void 0;
if (properties) {
this._resolveAnimations().update(this, properties);
}
if (changed && options.external) {
options.external.call(this, {
chart: this.chart,
tooltip: this,
replay
});
}
}
drawCaret(tooltipPoint, ctx, size, options) {
const caretPosition = this.getCaretPosition(tooltipPoint, size, options);
ctx.lineTo(caretPosition.x1, caretPosition.y1);
ctx.lineTo(caretPosition.x2, caretPosition.y2);
ctx.lineTo(caretPosition.x3, caretPosition.y3);
}
getCaretPosition(tooltipPoint, size, options) {
const { xAlign, yAlign } = this;
const { caretSize, cornerRadius } = options;
const { topLeft, topRight, bottomLeft, bottomRight } = toTRBLCorners(cornerRadius);
const { x: ptX, y: ptY } = tooltipPoint;
const { width, height } = size;
let x1, x2, x3, y1, y2, y3;
if (yAlign === "center") {
y2 = ptY + height / 2;
if (xAlign === "left") {
x1 = ptX;
x2 = x1 - caretSize;
y1 = y2 + caretSize;
y3 = y2 - caretSize;
} else {
x1 = ptX + width;
x2 = x1 + caretSize;
y1 = y2 - caretSize;
y3 = y2 + caretSize;
}
x3 = x1;
} else {
if (xAlign === "left") {
x2 = ptX + Math.max(topLeft, bottomLeft) + caretSize;
} else if (xAlign === "right") {
x2 = ptX + width - Math.max(topRight, bottomRight) - caretSize;
} else {
x2 = this.caretX;
}
if (yAlign === "top") {
y1 = ptY;
y2 = y1 - caretSize;
x1 = x2 - caretSize;
x3 = x2 + caretSize;
} else {
y1 = ptY + height;
y2 = y1 + caretSize;
x1 = x2 + caretSize;
x3 = x2 - caretSize;
}
y3 = y1;
}
return {
x1,
x2,
x3,
y1,
y2,
y3
};
}
drawTitle(pt2, ctx, options) {
const title = this.title;
const length = title.length;
let titleFont, titleSpacing, i2;
if (length) {
const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);
pt2.x = getAlignedX(this, options.titleAlign, options);
ctx.textAlign = rtlHelper.textAlign(options.titleAlign);
ctx.textBaseline = "middle";
titleFont = toFont(options.titleFont);
titleSpacing = options.titleSpacing;
ctx.fillStyle = options.titleColor;
ctx.font = titleFont.string;
for (i2 = 0; i2 < length; ++i2) {
ctx.fillText(title[i2], rtlHelper.x(pt2.x), pt2.y + titleFont.lineHeight / 2);
pt2.y += titleFont.lineHeight + titleSpacing;
if (i2 + 1 === length) {
pt2.y += options.titleMarginBottom - titleSpacing;
}
}
}
}
_drawColorBox(ctx, pt2, i2, rtlHelper, options) {
const labelColor = this.labelColors[i2];
const labelPointStyle = this.labelPointStyles[i2];
const { boxHeight, boxWidth } = options;
const bodyFont = toFont(options.bodyFont);
const colorX = getAlignedX(this, "left", options);
const rtlColorX = rtlHelper.x(colorX);
const yOffSet = boxHeight < bodyFont.lineHeight ? (bodyFont.lineHeight - boxHeight) / 2 : 0;
const colorY = pt2.y + yOffSet;
if (options.usePointStyle) {
const drawOptions = {
radius: Math.min(boxWidth, boxHeight) / 2,
pointStyle: labelPointStyle.pointStyle,
rotation: labelPointStyle.rotation,
borderWidth: 1
};
const centerX = rtlHelper.leftForLtr(rtlColorX, boxWidth) + boxWidth / 2;
const centerY = colorY + boxHeight / 2;
ctx.strokeStyle = options.multiKeyBackground;
ctx.fillStyle = options.multiKeyBackground;
drawPoint(ctx, drawOptions, centerX, centerY);
ctx.strokeStyle = labelColor.borderColor;
ctx.fillStyle = labelColor.backgroundColor;
drawPoint(ctx, drawOptions, centerX, centerY);
} else {
ctx.lineWidth = isObject(labelColor.borderWidth) ? Math.max(...Object.values(labelColor.borderWidth)) : labelColor.borderWidth || 1;
ctx.strokeStyle = labelColor.borderColor;
ctx.setLineDash(labelColor.borderDash || []);
ctx.lineDashOffset = labelColor.borderDashOffset || 0;
const outerX = rtlHelper.leftForLtr(rtlColorX, boxWidth);
const innerX = rtlHelper.leftForLtr(rtlHelper.xPlus(rtlColorX, 1), boxWidth - 2);
const borderRadius = toTRBLCorners(labelColor.borderRadius);
if (Object.values(borderRadius).some((v2) => v2 !== 0)) {
ctx.beginPath();
ctx.fillStyle = options.multiKeyBackground;
addRoundedRectPath(ctx, {
x: outerX,
y: colorY,
w: boxWidth,
h: boxHeight,
radius: borderRadius
});
ctx.fill();
ctx.stroke();
ctx.fillStyle = labelColor.backgroundColor;
ctx.beginPath();
addRoundedRectPath(ctx, {
x: innerX,
y: colorY + 1,
w: boxWidth - 2,
h: boxHeight - 2,
radius: borderRadius
});
ctx.fill();
} else {
ctx.fillStyle = options.multiKeyBackground;
ctx.fillRect(outerX, colorY, boxWidth, boxHeight);
ctx.strokeRect(outerX, colorY, boxWidth, boxHeight);
ctx.fillStyle = labelColor.backgroundColor;
ctx.fillRect(innerX, colorY + 1, boxWidth - 2, boxHeight - 2);
}
}
ctx.fillStyle = this.labelTextColors[i2];
}
drawBody(pt2, ctx, options) {
const { body } = this;
const { bodySpacing, bodyAlign, displayColors, boxHeight, boxWidth, boxPadding } = options;
const bodyFont = toFont(options.bodyFont);
let bodyLineHeight = bodyFont.lineHeight;
let xLinePadding = 0;
const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);
const fillLineOfText = function(line) {
ctx.fillText(line, rtlHelper.x(pt2.x + xLinePadding), pt2.y + bodyLineHeight / 2);
pt2.y += bodyLineHeight + bodySpacing;
};
const bodyAlignForCalculation = rtlHelper.textAlign(bodyAlign);
let bodyItem, textColor, lines, i2, j2, ilen, jlen;
ctx.textAlign = bodyAlign;
ctx.textBaseline = "middle";
ctx.font = bodyFont.string;
pt2.x = getAlignedX(this, bodyAlignForCalculation, options);
ctx.fillStyle = options.bodyColor;
each(this.beforeBody, fillLineOfText);
xLinePadding = displayColors && bodyAlignForCalculation !== "right" ? bodyAlign === "center" ? boxWidth / 2 + boxPadding : boxWidth + 2 + boxPadding : 0;
for (i2 = 0, ilen = body.length; i2 < ilen; ++i2) {
bodyItem = body[i2];
textColor = this.labelTextColors[i2];
ctx.fillStyle = textColor;
each(bodyItem.before, fillLineOfText);
lines = bodyItem.lines;
if (displayColors && lines.length) {
this._drawColorBox(ctx, pt2, i2, rtlHelper, options);
bodyLineHeight = Math.max(bodyFont.lineHeight, boxHeight);
}
for (j2 = 0, jlen = lines.length; j2 < jlen; ++j2) {
fillLineOfText(lines[j2]);
bodyLineHeight = bodyFont.lineHeight;
}
each(bodyItem.after, fillLineOfText);
}
xLinePadding = 0;
bodyLineHeight = bodyFont.lineHeight;
each(this.afterBody, fillLineOfText);
pt2.y -= bodySpacing;
}
drawFooter(pt2, ctx, options) {
const footer = this.footer;
const length = footer.length;
let footerFont, i2;
if (length) {
const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);
pt2.x = getAlignedX(this, options.footerAlign, options);
pt2.y += options.footerMarginTop;
ctx.textAlign = rtlHelper.textAlign(options.footerAlign);
ctx.textBaseline = "middle";
footerFont = toFont(options.footerFont);
ctx.fillStyle = options.footerColor;
ctx.font = footerFont.string;
for (i2 = 0; i2 < length; ++i2) {
ctx.fillText(footer[i2], rtlHelper.x(pt2.x), pt2.y + footerFont.lineHeight / 2);
pt2.y += footerFont.lineHeight + options.footerSpacing;
}
}
}
drawBackground(pt2, ctx, tooltipSize, options) {
const { xAlign, yAlign } = this;
const { x: x2, y: y2 } = pt2;
const { width, height } = tooltipSize;
const { topLeft, topRight, bottomLeft, bottomRight } = toTRBLCorners(options.cornerRadius);
ctx.fillStyle = options.backgroundColor;
ctx.strokeStyle = options.borderColor;
ctx.lineWidth = options.borderWidth;
ctx.beginPath();
ctx.moveTo(x2 + topLeft, y2);
if (yAlign === "top") {
this.drawCaret(pt2, ctx, tooltipSize, options);
}
ctx.lineTo(x2 + width - topRight, y2);
ctx.quadraticCurveTo(x2 + width, y2, x2 + width, y2 + topRight);
if (yAlign === "center" && xAlign === "right") {
this.drawCaret(pt2, ctx, tooltipSize, options);
}
ctx.lineTo(x2 + width, y2 + height - bottomRight);
ctx.quadraticCurveTo(x2 + width, y2 + height, x2 + width - bottomRight, y2 + height);
if (yAlign === "bottom") {
this.drawCaret(pt2, ctx, tooltipSize, options);
}
ctx.lineTo(x2 + bottomLeft, y2 + height);
ctx.quadraticCurveTo(x2, y2 + height, x2, y2 + height - bottomLeft);
if (yAlign === "center" && xAlign === "left") {
this.drawCaret(pt2, ctx, tooltipSize, options);
}
ctx.lineTo(x2, y2 + topLeft);
ctx.quadraticCurveTo(x2, y2, x2 + topLeft, y2);
ctx.closePath();
ctx.fill();
if (options.borderWidth > 0) {
ctx.stroke();
}
}
_updateAnimationTarget(options) {
const chart = this.chart;
const anims = this.$animations;
const animX = anims && anims.x;
const animY = anims && anims.y;
if (animX || animY) {
const position = positioners[options.position].call(this, this._active, this._eventPosition);
if (!position) {
return;
}
const size = this._size = getTooltipSize(this, options);
const positionAndSize = Object.assign({}, position, this._size);
const alignment = determineAlignment(chart, options, positionAndSize);
const point = getBackgroundPoint(options, positionAndSize, alignment, chart);
if (animX._to !== point.x || animY._to !== point.y) {
this.xAlign = alignment.xAlign;
this.yAlign = alignment.yAlign;
this.width = size.width;
this.height = size.height;
this.caretX = position.x;
this.caretY = position.y;
this._resolveAnimations().update(this, point);
}
}
}
_willRender() {
return !!this.opacity;
}
draw(ctx) {
const options = this.options.setContext(this.getContext());
let opacity = this.opacity;
if (!opacity) {
return;
}
this._updateAnimationTarget(options);
const tooltipSize = {
width: this.width,
height: this.height
};
const pt2 = {
x: this.x,
y: this.y
};
opacity = Math.abs(opacity) < 1e-3 ? 0 : opacity;
const padding = toPadding(options.padding);
const hasTooltipContent = this.title.length || this.beforeBody.length || this.body.length || this.afterBody.length || this.footer.length;
if (options.enabled && hasTooltipContent) {
ctx.save();
ctx.globalAlpha = opacity;
this.drawBackground(pt2, ctx, tooltipSize, options);
overrideTextDirection(ctx, options.textDirection);
pt2.y += padding.top;
this.drawTitle(pt2, ctx, options);
this.drawBody(pt2, ctx, options);
this.drawFooter(pt2, ctx, options);
restoreTextDirection(ctx, options.textDirection);
ctx.restore();
}
}
getActiveElements() {
return this._active || [];
}
setActiveElements(activeElements, eventPosition) {
const lastActive = this._active;
const active = activeElements.map(({ datasetIndex, index }) => {
const meta = this.chart.getDatasetMeta(datasetIndex);
if (!meta) {
throw new Error("Cannot find a dataset at index " + datasetIndex);
}
return {
datasetIndex,
element: meta.data[index],
index
};
});
const changed = !_elementsEqual(lastActive, active);
const positionChanged = this._positionChanged(active, eventPosition);
if (changed || positionChanged) {
this._active = active;
this._eventPosition = eventPosition;
this._ignoreReplayEvents = true;
this.update(true);
}
}
handleEvent(e2, replay, inChartArea = true) {
if (replay && this._ignoreReplayEvents) {
return false;
}
this._ignoreReplayEvents = false;
const options = this.options;
const lastActive = this._active || [];
const active = this._getActiveElements(e2, lastActive, replay, inChartArea);
const positionChanged = this._positionChanged(active, e2);
const changed = replay || !_elementsEqual(active, lastActive) || positionChanged;
if (changed) {
this._active = active;
if (options.enabled || options.external) {
this._eventPosition = {
x: e2.x,
y: e2.y
};
this.update(true, replay);
}
}
return changed;
}
_getActiveElements(e2, lastActive, replay, inChartArea) {
const options = this.options;
if (e2.type === "mouseout") {
return [];
}
if (!inChartArea) {
return lastActive.filter((i2) => this.chart.data.datasets[i2.datasetIndex] && this.chart.getDatasetMeta(i2.datasetIndex).controller.getParsed(i2.index) !== void 0);
}
const active = this.chart.getElementsAtEventForMode(e2, options.mode, options, replay);
if (options.reverse) {
active.reverse();
}
return active;
}
_positionChanged(active, e2) {
const { caretX, caretY, options } = this;
const position = positioners[options.position].call(this, active, e2);
return position !== false && (caretX !== position.x || caretY !== position.y);
}
};
__publicField(Tooltip, "positioners", positioners);
var plugin_tooltip = {
id: "tooltip",
_element: Tooltip,
positioners,
afterInit(chart, _args, options) {
if (options) {
chart.tooltip = new Tooltip({
chart,
options
});
}
},
beforeUpdate(chart, _args, options) {
if (chart.tooltip) {
chart.tooltip.initialize(options);
}
},
reset(chart, _args, options) {
if (chart.tooltip) {
chart.tooltip.initialize(options);
}
},
afterDraw(chart) {
const tooltip = chart.tooltip;
if (tooltip && tooltip._willRender()) {
const args = {
tooltip
};
if (chart.notifyPlugins("beforeTooltipDraw", {
...args,
cancelable: true
}) === false) {
return;
}
tooltip.draw(chart.ctx);
chart.notifyPlugins("afterTooltipDraw", args);
}
},
afterEvent(chart, args) {
if (chart.tooltip) {
const useFinalPosition = args.replay;
if (chart.tooltip.handleEvent(args.event, useFinalPosition, args.inChartArea)) {
args.changed = true;
}
}
},
defaults: {
enabled: true,
external: null,
position: "average",
backgroundColor: "rgba(0,0,0,0.8)",
titleColor: "#fff",
titleFont: {
weight: "bold"
},
titleSpacing: 2,
titleMarginBottom: 6,
titleAlign: "left",
bodyColor: "#fff",
bodySpacing: 2,
bodyFont: {},
bodyAlign: "left",
footerColor: "#fff",
footerSpacing: 2,
footerMarginTop: 6,
footerFont: {
weight: "bold"
},
footerAlign: "left",
padding: 6,
caretPadding: 2,
caretSize: 5,
cornerRadius: 6,
boxHeight: (ctx, opts) => opts.bodyFont.size,
boxWidth: (ctx, opts) => opts.bodyFont.size,
multiKeyBackground: "#fff",
displayColors: true,
boxPadding: 0,
borderColor: "rgba(0,0,0,0)",
borderWidth: 0,
animation: {
duration: 400,
easing: "easeOutQuart"
},
animations: {
numbers: {
type: "number",
properties: [
"x",
"y",
"width",
"height",
"caretX",
"caretY"
]
},
opacity: {
easing: "linear",
duration: 200
}
},
callbacks: defaultCallbacks
},
defaultRoutes: {
bodyFont: "font",
footerFont: "font",
titleFont: "font"
},
descriptors: {
_scriptable: (name) => name !== "filter" && name !== "itemSort" && name !== "external",
_indexable: false,
callbacks: {
_scriptable: false,
_indexable: false
},
animation: {
_fallback: false
},
animations: {
_fallback: "animation"
}
},
additionalOptionScopes: [
"interaction"
]
};
var addIfString = (labels, raw, index, addedLabels) => {
if (typeof raw === "string") {
index = labels.push(raw) - 1;
addedLabels.unshift({
index,
label: raw
});
} else if (isNaN(raw)) {
index = null;
}
return index;
};
function findOrAddLabel(labels, raw, index, addedLabels) {
const first = labels.indexOf(raw);
if (first === -1) {
return addIfString(labels, raw, index, addedLabels);
}
const last = labels.lastIndexOf(raw);
return first !== last ? index : first;
}
var validIndex = (index, max) => index === null ? null : _limitValue(Math.round(index), 0, max);
function _getLabelForValue(value) {
const labels = this.getLabels();
if (value >= 0 && value < labels.length) {
return labels[value];
}
return value;
}
var CategoryScale = class extends Scale {
constructor(cfg) {
super(cfg);
this._startValue = void 0;
this._valueRange = 0;
this._addedLabels = [];
}
init(scaleOptions) {
const added = this._addedLabels;
if (added.length) {
const labels = this.getLabels();
for (const { index, label } of added) {
if (labels[index] === label) {
labels.splice(index, 1);
}
}
this._addedLabels = [];
}
super.init(scaleOptions);
}
parse(raw, index) {
if (isNullOrUndef(raw)) {
return null;
}
const labels = this.getLabels();
index = isFinite(index) && labels[index] === raw ? index : findOrAddLabel(labels, raw, valueOrDefault(index, raw), this._addedLabels);
return validIndex(index, labels.length - 1);
}
determineDataLimits() {
const { minDefined, maxDefined } = this.getUserBounds();
let { min, max } = this.getMinMax(true);
if (this.options.bounds === "ticks") {
if (!minDefined) {
min = 0;
}
if (!maxDefined) {
max = this.getLabels().length - 1;
}
}
this.min = min;
this.max = max;
}
buildTicks() {
const min = this.min;
const max = this.max;
const offset = this.options.offset;
const ticks = [];
let labels = this.getLabels();
labels = min === 0 && max === labels.length - 1 ? labels : labels.slice(min, max + 1);
this._valueRange = Math.max(labels.length - (offset ? 0 : 1), 1);
this._startValue = this.min - (offset ? 0.5 : 0);
for (let value = min; value <= max; value++) {
ticks.push({
value
});
}
return ticks;
}
getLabelForValue(value) {
return _getLabelForValue.call(this, value);
}
configure() {
super.configure();
if (!this.isHorizontal()) {
this._reversePixels = !this._reversePixels;
}
}
getPixelForValue(value) {
if (typeof value !== "number") {
value = this.parse(value);
}
return value === null ? NaN : this.getPixelForDecimal((value - this._startValue) / this._valueRange);
}
getPixelForTick(index) {
const ticks = this.ticks;
if (index < 0 || index > ticks.length - 1) {
return null;
}
return this.getPixelForValue(ticks[index].value);
}
getValueForPixel(pixel) {
return Math.round(this._startValue + this.getDecimalForPixel(pixel) * this._valueRange);
}
getBasePixel() {
return this.bottom;
}
};
__publicField(CategoryScale, "id", "category");
__publicField(CategoryScale, "defaults", {
ticks: {
callback: _getLabelForValue
}
});
function generateTicks$1(generationOptions, dataRange) {
const ticks = [];
const MIN_SPACING = 1e-14;
const { bounds, step, min, max, precision, count, maxTicks, maxDigits, includeBounds } = generationOptions;
const unit = step || 1;
const maxSpaces = maxTicks - 1;
const { min: rmin, max: rmax } = dataRange;
const minDefined = !isNullOrUndef(min);
const maxDefined = !isNullOrUndef(max);
const countDefined = !isNullOrUndef(count);
const minSpacing = (rmax - rmin) / (maxDigits + 1);
let spacing = niceNum((rmax - rmin) / maxSpaces / unit) * unit;
let factor, niceMin, niceMax, numSpaces;
if (spacing < MIN_SPACING && !minDefined && !maxDefined) {
return [
{
value: rmin
},
{
value: rmax
}
];
}
numSpaces = Math.ceil(rmax / spacing) - Math.floor(rmin / spacing);
if (numSpaces > maxSpaces) {
spacing = niceNum(numSpaces * spacing / maxSpaces / unit) * unit;
}
if (!isNullOrUndef(precision)) {
factor = Math.pow(10, precision);
spacing = Math.ceil(spacing * factor) / factor;
}
if (bounds === "ticks") {
niceMin = Math.floor(rmin / spacing) * spacing;
niceMax = Math.ceil(rmax / spacing) * spacing;
} else {
niceMin = rmin;
niceMax = rmax;
}
if (minDefined && maxDefined && step && almostWhole((max - min) / step, spacing / 1e3)) {
numSpaces = Math.round(Math.min((max - min) / spacing, maxTicks));
spacing = (max - min) / numSpaces;
niceMin = min;
niceMax = max;
} else if (countDefined) {
niceMin = minDefined ? min : niceMin;
niceMax = maxDefined ? max : niceMax;
numSpaces = count - 1;
spacing = (niceMax - niceMin) / numSpaces;
} else {
numSpaces = (niceMax - niceMin) / spacing;
if (almostEquals(numSpaces, Math.round(numSpaces), spacing / 1e3)) {
numSpaces = Math.round(numSpaces);
} else {
numSpaces = Math.ceil(numSpaces);
}
}
const decimalPlaces = Math.max(_decimalPlaces(spacing), _decimalPlaces(niceMin));
factor = Math.pow(10, isNullOrUndef(precision) ? decimalPlaces : precision);
niceMin = Math.round(niceMin * factor) / factor;
niceMax = Math.round(niceMax * factor) / factor;
let j2 = 0;
if (minDefined) {
if (includeBounds && niceMin !== min) {
ticks.push({
value: min
});
if (niceMin < min) {
j2++;
}
if (almostEquals(Math.round((niceMin + j2 * spacing) * factor) / factor, min, relativeLabelSize(min, minSpacing, generationOptions))) {
j2++;
}
} else if (niceMin < min) {
j2++;
}
}
for (; j2 < numSpaces; ++j2) {
const tickValue = Math.round((niceMin + j2 * spacing) * factor) / factor;
if (maxDefined && tickValue > max) {
break;
}
ticks.push({
value: tickValue
});
}
if (maxDefined && includeBounds && niceMax !== max) {
if (ticks.length && almostEquals(ticks[ticks.length - 1].value, max, relativeLabelSize(max, minSpacing, generationOptions))) {
ticks[ticks.length - 1].value = max;
} else {
ticks.push({
value: max
});
}
} else if (!maxDefined || niceMax === max) {
ticks.push({
value: niceMax
});
}
return ticks;
}
function relativeLabelSize(value, minSpacing, { horizontal, minRotation }) {
const rad = toRadians(minRotation);
const ratio = (horizontal ? Math.sin(rad) : Math.cos(rad)) || 1e-3;
const length = 0.75 * minSpacing * ("" + value).length;
return Math.min(minSpacing / ratio, length);
}
var LinearScaleBase = class extends Scale {
constructor(cfg) {
super(cfg);
this.start = void 0;
this.end = void 0;
this._startValue = void 0;
this._endValue = void 0;
this._valueRange = 0;
}
parse(raw, index) {
if (isNullOrUndef(raw)) {
return null;
}
if ((typeof raw === "number" || raw instanceof Number) && !isFinite(+raw)) {
return null;
}
return +raw;
}
handleTickRangeOptions() {
const { beginAtZero } = this.options;
const { minDefined, maxDefined } = this.getUserBounds();
let { min, max } = this;
const setMin = (v2) => min = minDefined ? min : v2;
const setMax = (v2) => max = maxDefined ? max : v2;
if (beginAtZero) {
const minSign = sign(min);
const maxSign = sign(max);
if (minSign < 0 && maxSign < 0) {
setMax(0);
} else if (minSign > 0 && maxSign > 0) {
setMin(0);
}
}
if (min === max) {
let offset = max === 0 ? 1 : Math.abs(max * 0.05);
setMax(max + offset);
if (!beginAtZero) {
setMin(min - offset);
}
}
this.min = min;
this.max = max;
}
getTickLimit() {
const tickOpts = this.options.ticks;
let { maxTicksLimit, stepSize } = tickOpts;
let maxTicks;
if (stepSize) {
maxTicks = Math.ceil(this.max / stepSize) - Math.floor(this.min / stepSize) + 1;
if (maxTicks > 1e3) {
console.warn(`scales.${this.id}.ticks.stepSize: ${stepSize} would result generating up to ${maxTicks} ticks. Limiting to 1000.`);
maxTicks = 1e3;
}
} else {
maxTicks = this.computeTickLimit();
maxTicksLimit = maxTicksLimit || 11;
}
if (maxTicksLimit) {
maxTicks = Math.min(maxTicksLimit, maxTicks);
}
return maxTicks;
}
computeTickLimit() {
return Number.POSITIVE_INFINITY;
}
buildTicks() {
const opts = this.options;
const tickOpts = opts.ticks;
let maxTicks = this.getTickLimit();
maxTicks = Math.max(2, maxTicks);
const numericGeneratorOptions = {
maxTicks,
bounds: opts.bounds,
min: opts.min,
max: opts.max,
precision: tickOpts.precision,
step: tickOpts.stepSize,
count: tickOpts.count,
maxDigits: this._maxDigits(),
horizontal: this.isHorizontal(),
minRotation: tickOpts.minRotation || 0,
includeBounds: tickOpts.includeBounds !== false
};
const dataRange = this._range || this;
const ticks = generateTicks$1(numericGeneratorOptions, dataRange);
if (opts.bounds === "ticks") {
_setMinAndMaxByKey(ticks, this, "value");
}
if (opts.reverse) {
ticks.reverse();
this.start = this.max;
this.end = this.min;
} else {
this.start = this.min;
this.end = this.max;
}
return ticks;
}
configure() {
const ticks = this.ticks;
let start = this.min;
let end = this.max;
super.configure();
if (this.options.offset && ticks.length) {
const offset = (end - start) / Math.max(ticks.length - 1, 1) / 2;
start -= offset;
end += offset;
}
this._startValue = start;
this._endValue = end;
this._valueRange = end - start;
}
getLabelForValue(value) {
return formatNumber(value, this.chart.options.locale, this.options.ticks.format);
}
};
var LinearScale = class extends LinearScaleBase {
determineDataLimits() {
const { min, max } = this.getMinMax(true);
this.min = isNumberFinite(min) ? min : 0;
this.max = isNumberFinite(max) ? max : 1;
this.handleTickRangeOptions();
}
computeTickLimit() {
const horizontal = this.isHorizontal();
const length = horizontal ? this.width : this.height;
const minRotation = toRadians(this.options.ticks.minRotation);
const ratio = (horizontal ? Math.sin(minRotation) : Math.cos(minRotation)) || 1e-3;
const tickFont = this._resolveTickFontOptions(0);
return Math.ceil(length / Math.min(40, tickFont.lineHeight / ratio));
}
getPixelForValue(value) {
return value === null ? NaN : this.getPixelForDecimal((value - this._startValue) / this._valueRange);
}
getValueForPixel(pixel) {
return this._startValue + this.getDecimalForPixel(pixel) * this._valueRange;
}
};
__publicField(LinearScale, "id", "linear");
__publicField(LinearScale, "defaults", {
ticks: {
callback: Ticks.formatters.numeric
}
});
var log10Floor = (v2) => Math.floor(log10(v2));
var changeExponent = (v2, m2) => Math.pow(10, log10Floor(v2) + m2);
function isMajor(tickVal) {
const remain = tickVal / Math.pow(10, log10Floor(tickVal));
return remain === 1;
}
function steps(min, max, rangeExp) {
const rangeStep = Math.pow(10, rangeExp);
const start = Math.floor(min / rangeStep);
const end = Math.ceil(max / rangeStep);
return end - start;
}
function startExp(min, max) {
const range = max - min;
let rangeExp = log10Floor(range);
while (steps(min, max, rangeExp) > 10) {
rangeExp++;
}
while (steps(min, max, rangeExp) < 10) {
rangeExp--;
}
return Math.min(rangeExp, log10Floor(min));
}
function generateTicks(generationOptions, { min, max }) {
min = finiteOrDefault(generationOptions.min, min);
const ticks = [];
const minExp = log10Floor(min);
let exp = startExp(min, max);
let precision = exp < 0 ? Math.pow(10, Math.abs(exp)) : 1;
const stepSize = Math.pow(10, exp);
const base = minExp > exp ? Math.pow(10, minExp) : 0;
const start = Math.round((min - base) * precision) / precision;
const offset = Math.floor((min - base) / stepSize / 10) * stepSize * 10;
let significand = Math.floor((start - offset) / Math.pow(10, exp));
let value = finiteOrDefault(generationOptions.min, Math.round((base + offset + significand * Math.pow(10, exp)) * precision) / precision);
while (value < max) {
ticks.push({
value,
major: isMajor(value),
significand
});
if (significand >= 10) {
significand = significand < 15 ? 15 : 20;
} else {
significand++;
}
if (significand >= 20) {
exp++;
significand = 2;
precision = exp >= 0 ? 1 : precision;
}
value = Math.round((base + offset + significand * Math.pow(10, exp)) * precision) / precision;
}
const lastTick = finiteOrDefault(generationOptions.max, value);
ticks.push({
value: lastTick,
major: isMajor(lastTick),
significand
});
return ticks;
}
var LogarithmicScale = class extends Scale {
constructor(cfg) {
super(cfg);
this.start = void 0;
this.end = void 0;
this._startValue = void 0;
this._valueRange = 0;
}
parse(raw, index) {
const value = LinearScaleBase.prototype.parse.apply(this, [
raw,
index
]);
if (value === 0) {
this._zero = true;
return void 0;
}
return isNumberFinite(value) && value > 0 ? value : null;
}
determineDataLimits() {
const { min, max } = this.getMinMax(true);
this.min = isNumberFinite(min) ? Math.max(0, min) : null;
this.max = isNumberFinite(max) ? Math.max(0, max) : null;
if (this.options.beginAtZero) {
this._zero = true;
}
if (this._zero && this.min !== this._suggestedMin && !isNumberFinite(this._userMin)) {
this.min = min === changeExponent(this.min, 0) ? changeExponent(this.min, -1) : changeExponent(this.min, 0);
}
this.handleTickRangeOptions();
}
handleTickRangeOptions() {
const { minDefined, maxDefined } = this.getUserBounds();
let min = this.min;
let max = this.max;
const setMin = (v2) => min = minDefined ? min : v2;
const setMax = (v2) => max = maxDefined ? max : v2;
if (min === max) {
if (min <= 0) {
setMin(1);
setMax(10);
} else {
setMin(changeExponent(min, -1));
setMax(changeExponent(max, 1));
}
}
if (min <= 0) {
setMin(changeExponent(max, -1));
}
if (max <= 0) {
setMax(changeExponent(min, 1));
}
this.min = min;
this.max = max;
}
buildTicks() {
const opts = this.options;
const generationOptions = {
min: this._userMin,
max: this._userMax
};
const ticks = generateTicks(generationOptions, this);
if (opts.bounds === "ticks") {
_setMinAndMaxByKey(ticks, this, "value");
}
if (opts.reverse) {
ticks.reverse();
this.start = this.max;
this.end = this.min;
} else {
this.start = this.min;
this.end = this.max;
}
return ticks;
}
getLabelForValue(value) {
return value === void 0 ? "0" : formatNumber(value, this.chart.options.locale, this.options.ticks.format);
}
configure() {
const start = this.min;
super.configure();
this._startValue = log10(start);
this._valueRange = log10(this.max) - log10(start);
}
getPixelForValue(value) {
if (value === void 0 || value === 0) {
value = this.min;
}
if (value === null || isNaN(value)) {
return NaN;
}
return this.getPixelForDecimal(value === this.min ? 0 : (log10(value) - this._startValue) / this._valueRange);
}
getValueForPixel(pixel) {
const decimal = this.getDecimalForPixel(pixel);
return Math.pow(10, this._startValue + decimal * this._valueRange);
}
};
__publicField(LogarithmicScale, "id", "logarithmic");
__publicField(LogarithmicScale, "defaults", {
ticks: {
callback: Ticks.formatters.logarithmic,
major: {
enabled: true
}
}
});
function getTickBackdropHeight(opts) {
const tickOpts = opts.ticks;
if (tickOpts.display && opts.display) {
const padding = toPadding(tickOpts.backdropPadding);
return valueOrDefault(tickOpts.font && tickOpts.font.size, defaults2.font.size) + padding.height;
}
return 0;
}
function measureLabelSize(ctx, font, label) {
label = isArray(label) ? label : [
label
];
return {
w: _longestText(ctx, font.string, label),
h: label.length * font.lineHeight
};
}
function determineLimits(angle, pos, size, min, max) {
if (angle === min || angle === max) {
return {
start: pos - size / 2,
end: pos + size / 2
};
} else if (angle < min || angle > max) {
return {
start: pos - size,
end: pos
};
}
return {
start: pos,
end: pos + size
};
}
function fitWithPointLabels(scale) {
const orig = {
l: scale.left + scale._padding.left,
r: scale.right - scale._padding.right,
t: scale.top + scale._padding.top,
b: scale.bottom - scale._padding.bottom
};
const limits = Object.assign({}, orig);
const labelSizes = [];
const padding = [];
const valueCount = scale._pointLabels.length;
const pointLabelOpts = scale.options.pointLabels;
const additionalAngle = pointLabelOpts.centerPointLabels ? PI / valueCount : 0;
for (let i2 = 0; i2 < valueCount; i2++) {
const opts = pointLabelOpts.setContext(scale.getPointLabelContext(i2));
padding[i2] = opts.padding;
const pointPosition = scale.getPointPosition(i2, scale.drawingArea + padding[i2], additionalAngle);
const plFont = toFont(opts.font);
const textSize = measureLabelSize(scale.ctx, plFont, scale._pointLabels[i2]);
labelSizes[i2] = textSize;
const angleRadians = _normalizeAngle(scale.getIndexAngle(i2) + additionalAngle);
const angle = Math.round(toDegrees(angleRadians));
const hLimits = determineLimits(angle, pointPosition.x, textSize.w, 0, 180);
const vLimits = determineLimits(angle, pointPosition.y, textSize.h, 90, 270);
updateLimits(limits, orig, angleRadians, hLimits, vLimits);
}
scale.setCenterPoint(orig.l - limits.l, limits.r - orig.r, orig.t - limits.t, limits.b - orig.b);
scale._pointLabelItems = buildPointLabelItems(scale, labelSizes, padding);
}
function updateLimits(limits, orig, angle, hLimits, vLimits) {
const sin = Math.abs(Math.sin(angle));
const cos = Math.abs(Math.cos(angle));
let x2 = 0;
let y2 = 0;
if (hLimits.start < orig.l) {
x2 = (orig.l - hLimits.start) / sin;
limits.l = Math.min(limits.l, orig.l - x2);
} else if (hLimits.end > orig.r) {
x2 = (hLimits.end - orig.r) / sin;
limits.r = Math.max(limits.r, orig.r + x2);
}
if (vLimits.start < orig.t) {
y2 = (orig.t - vLimits.start) / cos;
limits.t = Math.min(limits.t, orig.t - y2);
} else if (vLimits.end > orig.b) {
y2 = (vLimits.end - orig.b) / cos;
limits.b = Math.max(limits.b, orig.b + y2);
}
}
function createPointLabelItem(scale, index, itemOpts) {
const outerDistance = scale.drawingArea;
const { extra, additionalAngle, padding, size } = itemOpts;
const pointLabelPosition = scale.getPointPosition(index, outerDistance + extra + padding, additionalAngle);
const angle = Math.round(toDegrees(_normalizeAngle(pointLabelPosition.angle + HALF_PI)));
const y2 = yForAngle(pointLabelPosition.y, size.h, angle);
const textAlign = getTextAlignForAngle(angle);
const left = leftForTextAlign(pointLabelPosition.x, size.w, textAlign);
return {
visible: true,
x: pointLabelPosition.x,
y: y2,
textAlign,
left,
top: y2,
right: left + size.w,
bottom: y2 + size.h
};
}
function isNotOverlapped(item, area) {
if (!area) {
return true;
}
const { left, top, right, bottom } = item;
const apexesInArea = _isPointInArea({
x: left,
y: top
}, area) || _isPointInArea({
x: left,
y: bottom
}, area) || _isPointInArea({
x: right,
y: top
}, area) || _isPointInArea({
x: right,
y: bottom
}, area);
return !apexesInArea;
}
function buildPointLabelItems(scale, labelSizes, padding) {
const items = [];
const valueCount = scale._pointLabels.length;
const opts = scale.options;
const { centerPointLabels, display } = opts.pointLabels;
const itemOpts = {
extra: getTickBackdropHeight(opts) / 2,
additionalAngle: centerPointLabels ? PI / valueCount : 0
};
let area;
for (let i2 = 0; i2 < valueCount; i2++) {
itemOpts.padding = padding[i2];
itemOpts.size = labelSizes[i2];
const item = createPointLabelItem(scale, i2, itemOpts);
items.push(item);
if (display === "auto") {
item.visible = isNotOverlapped(item, area);
if (item.visible) {
area = item;
}
}
}
return items;
}
function getTextAlignForAngle(angle) {
if (angle === 0 || angle === 180) {
return "center";
} else if (angle < 180) {
return "left";
}
return "right";
}
function leftForTextAlign(x2, w2, align) {
if (align === "right") {
x2 -= w2;
} else if (align === "center") {
x2 -= w2 / 2;
}
return x2;
}
function yForAngle(y2, h6, angle) {
if (angle === 90 || angle === 270) {
y2 -= h6 / 2;
} else if (angle > 270 || angle < 90) {
y2 -= h6;
}
return y2;
}
function drawPointLabelBox(ctx, opts, item) {
const { left, top, right, bottom } = item;
const { backdropColor } = opts;
if (!isNullOrUndef(backdropColor)) {
const borderRadius = toTRBLCorners(opts.borderRadius);
const padding = toPadding(opts.backdropPadding);
ctx.fillStyle = backdropColor;
const backdropLeft = left - padding.left;
const backdropTop = top - padding.top;
const backdropWidth = right - left + padding.width;
const backdropHeight = bottom - top + padding.height;
if (Object.values(borderRadius).some((v2) => v2 !== 0)) {
ctx.beginPath();
addRoundedRectPath(ctx, {
x: backdropLeft,
y: backdropTop,
w: backdropWidth,
h: backdropHeight,
radius: borderRadius
});
ctx.fill();
} else {
ctx.fillRect(backdropLeft, backdropTop, backdropWidth, backdropHeight);
}
}
}
function drawPointLabels(scale, labelCount) {
const { ctx, options: { pointLabels } } = scale;
for (let i2 = labelCount - 1; i2 >= 0; i2--) {
const item = scale._pointLabelItems[i2];
if (!item.visible) {
continue;
}
const optsAtIndex = pointLabels.setContext(scale.getPointLabelContext(i2));
drawPointLabelBox(ctx, optsAtIndex, item);
const plFont = toFont(optsAtIndex.font);
const { x: x2, y: y2, textAlign } = item;
renderText(ctx, scale._pointLabels[i2], x2, y2 + plFont.lineHeight / 2, plFont, {
color: optsAtIndex.color,
textAlign,
textBaseline: "middle"
});
}
}
function pathRadiusLine(scale, radius, circular, labelCount) {
const { ctx } = scale;
if (circular) {
ctx.arc(scale.xCenter, scale.yCenter, radius, 0, TAU);
} else {
let pointPosition = scale.getPointPosition(0, radius);
ctx.moveTo(pointPosition.x, pointPosition.y);
for (let i2 = 1; i2 < labelCount; i2++) {
pointPosition = scale.getPointPosition(i2, radius);
ctx.lineTo(pointPosition.x, pointPosition.y);
}
}
}
function drawRadiusLine(scale, gridLineOpts, radius, labelCount, borderOpts) {
const ctx = scale.ctx;
const circular = gridLineOpts.circular;
const { color: color2, lineWidth } = gridLineOpts;
if (!circular && !labelCount || !color2 || !lineWidth || radius < 0) {
return;
}
ctx.save();
ctx.strokeStyle = color2;
ctx.lineWidth = lineWidth;
ctx.setLineDash(borderOpts.dash);
ctx.lineDashOffset = borderOpts.dashOffset;
ctx.beginPath();
pathRadiusLine(scale, radius, circular, labelCount);
ctx.closePath();
ctx.stroke();
ctx.restore();
}
function createPointLabelContext(parent, index, label) {
return createContext(parent, {
label,
index,
type: "pointLabel"
});
}
var RadialLinearScale = class extends LinearScaleBase {
constructor(cfg) {
super(cfg);
this.xCenter = void 0;
this.yCenter = void 0;
this.drawingArea = void 0;
this._pointLabels = [];
this._pointLabelItems = [];
}
setDimensions() {
const padding = this._padding = toPadding(getTickBackdropHeight(this.options) / 2);
const w2 = this.width = this.maxWidth - padding.width;
const h6 = this.height = this.maxHeight - padding.height;
this.xCenter = Math.floor(this.left + w2 / 2 + padding.left);
this.yCenter = Math.floor(this.top + h6 / 2 + padding.top);
this.drawingArea = Math.floor(Math.min(w2, h6) / 2);
}
determineDataLimits() {
const { min, max } = this.getMinMax(false);
this.min = isNumberFinite(min) && !isNaN(min) ? min : 0;
this.max = isNumberFinite(max) && !isNaN(max) ? max : 0;
this.handleTickRangeOptions();
}
computeTickLimit() {
return Math.ceil(this.drawingArea / getTickBackdropHeight(this.options));
}
generateTickLabels(ticks) {
LinearScaleBase.prototype.generateTickLabels.call(this, ticks);
this._pointLabels = this.getLabels().map((value, index) => {
const label = callback(this.options.pointLabels.callback, [
value,
index
], this);
return label || label === 0 ? label : "";
}).filter((v2, i2) => this.chart.getDataVisibility(i2));
}
fit() {
const opts = this.options;
if (opts.display && opts.pointLabels.display) {
fitWithPointLabels(this);
} else {
this.setCenterPoint(0, 0, 0, 0);
}
}
setCenterPoint(leftMovement, rightMovement, topMovement, bottomMovement) {
this.xCenter += Math.floor((leftMovement - rightMovement) / 2);
this.yCenter += Math.floor((topMovement - bottomMovement) / 2);
this.drawingArea -= Math.min(this.drawingArea / 2, Math.max(leftMovement, rightMovement, topMovement, bottomMovement));
}
getIndexAngle(index) {
const angleMultiplier = TAU / (this._pointLabels.length || 1);
const startAngle = this.options.startAngle || 0;
return _normalizeAngle(index * angleMultiplier + toRadians(startAngle));
}
getDistanceFromCenterForValue(value) {
if (isNullOrUndef(value)) {
return NaN;
}
const scalingFactor = this.drawingArea / (this.max - this.min);
if (this.options.reverse) {
return (this.max - value) * scalingFactor;
}
return (value - this.min) * scalingFactor;
}
getValueForDistanceFromCenter(distance) {
if (isNullOrUndef(distance)) {
return NaN;
}
const scaledDistance = distance / (this.drawingArea / (this.max - this.min));
return this.options.reverse ? this.max - scaledDistance : this.min + scaledDistance;
}
getPointLabelContext(index) {
const pointLabels = this._pointLabels || [];
if (index >= 0 && index < pointLabels.length) {
const pointLabel = pointLabels[index];
return createPointLabelContext(this.getContext(), index, pointLabel);
}
}
getPointPosition(index, distanceFromCenter, additionalAngle = 0) {
const angle = this.getIndexAngle(index) - HALF_PI + additionalAngle;
return {
x: Math.cos(angle) * distanceFromCenter + this.xCenter,
y: Math.sin(angle) * distanceFromCenter + this.yCenter,
angle
};
}
getPointPositionForValue(index, value) {
return this.getPointPosition(index, this.getDistanceFromCenterForValue(value));
}
getBasePosition(index) {
return this.getPointPositionForValue(index || 0, this.getBaseValue());
}
getPointLabelPosition(index) {
const { left, top, right, bottom } = this._pointLabelItems[index];
return {
left,
top,
right,
bottom
};
}
drawBackground() {
const { backgroundColor, grid: { circular } } = this.options;
if (backgroundColor) {
const ctx = this.ctx;
ctx.save();
ctx.beginPath();
pathRadiusLine(this, this.getDistanceFromCenterForValue(this._endValue), circular, this._pointLabels.length);
ctx.closePath();
ctx.fillStyle = backgroundColor;
ctx.fill();
ctx.restore();
}
}
drawGrid() {
const ctx = this.ctx;
const opts = this.options;
const { angleLines, grid, border } = opts;
const labelCount = this._pointLabels.length;
let i2, offset, position;
if (opts.pointLabels.display) {
drawPointLabels(this, labelCount);
}
if (grid.display) {
this.ticks.forEach((tick, index) => {
if (index !== 0 || index === 0 && this.min < 0) {
offset = this.getDistanceFromCenterForValue(tick.value);
const context = this.getContext(index);
const optsAtIndex = grid.setContext(context);
const optsAtIndexBorder = border.setContext(context);
drawRadiusLine(this, optsAtIndex, offset, labelCount, optsAtIndexBorder);
}
});
}
if (angleLines.display) {
ctx.save();
for (i2 = labelCount - 1; i2 >= 0; i2--) {
const optsAtIndex = angleLines.setContext(this.getPointLabelContext(i2));
const { color: color2, lineWidth } = optsAtIndex;
if (!lineWidth || !color2) {
continue;
}
ctx.lineWidth = lineWidth;
ctx.strokeStyle = color2;
ctx.setLineDash(optsAtIndex.borderDash);
ctx.lineDashOffset = optsAtIndex.borderDashOffset;
offset = this.getDistanceFromCenterForValue(opts.reverse ? this.min : this.max);
position = this.getPointPosition(i2, offset);
ctx.beginPath();
ctx.moveTo(this.xCenter, this.yCenter);
ctx.lineTo(position.x, position.y);
ctx.stroke();
}
ctx.restore();
}
}
drawBorder() {
}
drawLabels() {
const ctx = this.ctx;
const opts = this.options;
const tickOpts = opts.ticks;
if (!tickOpts.display) {
return;
}
const startAngle = this.getIndexAngle(0);
let offset, width;
ctx.save();
ctx.translate(this.xCenter, this.yCenter);
ctx.rotate(startAngle);
ctx.textAlign = "center";
ctx.textBaseline = "middle";
this.ticks.forEach((tick, index) => {
if (index === 0 && this.min >= 0 && !opts.reverse) {
return;
}
const optsAtIndex = tickOpts.setContext(this.getContext(index));
const tickFont = toFont(optsAtIndex.font);
offset = this.getDistanceFromCenterForValue(this.ticks[index].value);
if (optsAtIndex.showLabelBackdrop) {
ctx.font = tickFont.string;
width = ctx.measureText(tick.label).width;
ctx.fillStyle = optsAtIndex.backdropColor;
const padding = toPadding(optsAtIndex.backdropPadding);
ctx.fillRect(-width / 2 - padding.left, -offset - tickFont.size / 2 - padding.top, width + padding.width, tickFont.size + padding.height);
}
renderText(ctx, tick.label, 0, -offset, tickFont, {
color: optsAtIndex.color,
strokeColor: optsAtIndex.textStrokeColor,
strokeWidth: optsAtIndex.textStrokeWidth
});
});
ctx.restore();
}
drawTitle() {
}
};
__publicField(RadialLinearScale, "id", "radialLinear");
__publicField(RadialLinearScale, "defaults", {
display: true,
animate: true,
position: "chartArea",
angleLines: {
display: true,
lineWidth: 1,
borderDash: [],
borderDashOffset: 0
},
grid: {
circular: false
},
startAngle: 0,
ticks: {
showLabelBackdrop: true,
callback: Ticks.formatters.numeric
},
pointLabels: {
backdropColor: void 0,
backdropPadding: 2,
display: true,
font: {
size: 10
},
callback(label) {
return label;
},
padding: 5,
centerPointLabels: false
}
});
__publicField(RadialLinearScale, "defaultRoutes", {
"angleLines.color": "borderColor",
"pointLabels.color": "color",
"ticks.color": "color"
});
__publicField(RadialLinearScale, "descriptors", {
angleLines: {
_fallback: "grid"
}
});
var INTERVALS = {
millisecond: {
common: true,
size: 1,
steps: 1e3
},
second: {
common: true,
size: 1e3,
steps: 60
},
minute: {
common: true,
size: 6e4,
steps: 60
},
hour: {
common: true,
size: 36e5,
steps: 24
},
day: {
common: true,
size: 864e5,
steps: 30
},
week: {
common: false,
size: 6048e5,
steps: 4
},
month: {
common: true,
size: 2628e6,
steps: 12
},
quarter: {
common: false,
size: 7884e6,
steps: 4
},
year: {
common: true,
size: 3154e7
}
};
var UNITS = /* @__PURE__ */ Object.keys(INTERVALS);
function sorter(a2, b2) {
return a2 - b2;
}
function parse2(scale, input) {
if (isNullOrUndef(input)) {
return null;
}
const adapter = scale._adapter;
const { parser, round: round2, isoWeekday } = scale._parseOpts;
let value = input;
if (typeof parser === "function") {
value = parser(value);
}
if (!isNumberFinite(value)) {
value = typeof parser === "string" ? adapter.parse(value, parser) : adapter.parse(value);
}
if (value === null) {
return null;
}
if (round2) {
value = round2 === "week" && (isNumber(isoWeekday) || isoWeekday === true) ? adapter.startOf(value, "isoWeek", isoWeekday) : adapter.startOf(value, round2);
}
return +value;
}
function determineUnitForAutoTicks(minUnit, min, max, capacity) {
const ilen = UNITS.length;
for (let i2 = UNITS.indexOf(minUnit); i2 < ilen - 1; ++i2) {
const interval = INTERVALS[UNITS[i2]];
const factor = interval.steps ? interval.steps : Number.MAX_SAFE_INTEGER;
if (interval.common && Math.ceil((max - min) / (factor * interval.size)) <= capacity) {
return UNITS[i2];
}
}
return UNITS[ilen - 1];
}
function determineUnitForFormatting(scale, numTicks, minUnit, min, max) {
for (let i2 = UNITS.length - 1; i2 >= UNITS.indexOf(minUnit); i2--) {
const unit = UNITS[i2];
if (INTERVALS[unit].common && scale._adapter.diff(max, min, unit) >= numTicks - 1) {
return unit;
}
}
return UNITS[minUnit ? UNITS.indexOf(minUnit) : 0];
}
function determineMajorUnit(unit) {
for (let i2 = UNITS.indexOf(unit) + 1, ilen = UNITS.length; i2 < ilen; ++i2) {
if (INTERVALS[UNITS[i2]].common) {
return UNITS[i2];
}
}
}
function addTick(ticks, time, timestamps) {
if (!timestamps) {
ticks[time] = true;
} else if (timestamps.length) {
const { lo, hi } = _lookup(timestamps, time);
const timestamp = timestamps[lo] >= time ? timestamps[lo] : timestamps[hi];
ticks[timestamp] = true;
}
}
function setMajorTicks(scale, ticks, map3, majorUnit) {
const adapter = scale._adapter;
const first = +adapter.startOf(ticks[0].value, majorUnit);
const last = ticks[ticks.length - 1].value;
let major, index;
for (major = first; major <= last; major = +adapter.add(major, 1, majorUnit)) {
index = map3[major];
if (index >= 0) {
ticks[index].major = true;
}
}
return ticks;
}
function ticksFromTimestamps(scale, values, majorUnit) {
const ticks = [];
const map3 = {};
const ilen = values.length;
let i2, value;
for (i2 = 0; i2 < ilen; ++i2) {
value = values[i2];
map3[value] = i2;
ticks.push({
value,
major: false
});
}
return ilen === 0 || !majorUnit ? ticks : setMajorTicks(scale, ticks, map3, majorUnit);
}
var TimeScale = class extends Scale {
constructor(props) {
super(props);
this._cache = {
data: [],
labels: [],
all: []
};
this._unit = "day";
this._majorUnit = void 0;
this._offsets = {};
this._normalized = false;
this._parseOpts = void 0;
}
init(scaleOpts, opts = {}) {
const time = scaleOpts.time || (scaleOpts.time = {});
const adapter = this._adapter = new adapters._date(scaleOpts.adapters.date);
adapter.init(opts);
mergeIf(time.displayFormats, adapter.formats());
this._parseOpts = {
parser: time.parser,
round: time.round,
isoWeekday: time.isoWeekday
};
super.init(scaleOpts);
this._normalized = opts.normalized;
}
parse(raw, index) {
if (raw === void 0) {
return null;
}
return parse2(this, raw);
}
beforeLayout() {
super.beforeLayout();
this._cache = {
data: [],
labels: [],
all: []
};
}
determineDataLimits() {
const options = this.options;
const adapter = this._adapter;
const unit = options.time.unit || "day";
let { min, max, minDefined, maxDefined } = this.getUserBounds();
function _applyBounds(bounds) {
if (!minDefined && !isNaN(bounds.min)) {
min = Math.min(min, bounds.min);
}
if (!maxDefined && !isNaN(bounds.max)) {
max = Math.max(max, bounds.max);
}
}
if (!minDefined || !maxDefined) {
_applyBounds(this._getLabelBounds());
if (options.bounds !== "ticks" || options.ticks.source !== "labels") {
_applyBounds(this.getMinMax(false));
}
}
min = isNumberFinite(min) && !isNaN(min) ? min : +adapter.startOf(Date.now(), unit);
max = isNumberFinite(max) && !isNaN(max) ? max : +adapter.endOf(Date.now(), unit) + 1;
this.min = Math.min(min, max - 1);
this.max = Math.max(min + 1, max);
}
_getLabelBounds() {
const arr = this.getLabelTimestamps();
let min = Number.POSITIVE_INFINITY;
let max = Number.NEGATIVE_INFINITY;
if (arr.length) {
min = arr[0];
max = arr[arr.length - 1];
}
return {
min,
max
};
}
buildTicks() {
const options = this.options;
const timeOpts = options.time;
const tickOpts = options.ticks;
const timestamps = tickOpts.source === "labels" ? this.getLabelTimestamps() : this._generate();
if (options.bounds === "ticks" && timestamps.length) {
this.min = this._userMin || timestamps[0];
this.max = this._userMax || timestamps[timestamps.length - 1];
}
const min = this.min;
const max = this.max;
const ticks = _filterBetween(timestamps, min, max);
this._unit = timeOpts.unit || (tickOpts.autoSkip ? determineUnitForAutoTicks(timeOpts.minUnit, this.min, this.max, this._getLabelCapacity(min)) : determineUnitForFormatting(this, ticks.length, timeOpts.minUnit, this.min, this.max));
this._majorUnit = !tickOpts.major.enabled || this._unit === "year" ? void 0 : determineMajorUnit(this._unit);
this.initOffsets(timestamps);
if (options.reverse) {
ticks.reverse();
}
return ticksFromTimestamps(this, ticks, this._majorUnit);
}
afterAutoSkip() {
if (this.options.offsetAfterAutoskip) {
this.initOffsets(this.ticks.map((tick) => +tick.value));
}
}
initOffsets(timestamps = []) {
let start = 0;
let end = 0;
let first, last;
if (this.options.offset && timestamps.length) {
first = this.getDecimalForValue(timestamps[0]);
if (timestamps.length === 1) {
start = 1 - first;
} else {
start = (this.getDecimalForValue(timestamps[1]) - first) / 2;
}
last = this.getDecimalForValue(timestamps[timestamps.length - 1]);
if (timestamps.length === 1) {
end = last;
} else {
end = (last - this.getDecimalForValue(timestamps[timestamps.length - 2])) / 2;
}
}
const limit = timestamps.length < 3 ? 0.5 : 0.25;
start = _limitValue(start, 0, limit);
end = _limitValue(end, 0, limit);
this._offsets = {
start,
end,
factor: 1 / (start + 1 + end)
};
}
_generate() {
const adapter = this._adapter;
const min = this.min;
const max = this.max;
const options = this.options;
const timeOpts = options.time;
const minor = timeOpts.unit || determineUnitForAutoTicks(timeOpts.minUnit, min, max, this._getLabelCapacity(min));
const stepSize = valueOrDefault(options.ticks.stepSize, 1);
const weekday = minor === "week" ? timeOpts.isoWeekday : false;
const hasWeekday = isNumber(weekday) || weekday === true;
const ticks = {};
let first = min;
let time, count;
if (hasWeekday) {
first = +adapter.startOf(first, "isoWeek", weekday);
}
first = +adapter.startOf(first, hasWeekday ? "day" : minor);
if (adapter.diff(max, min, minor) > 1e5 * stepSize) {
throw new Error(min + " and " + max + " are too far apart with stepSize of " + stepSize + " " + minor);
}
const timestamps = options.ticks.source === "data" && this.getDataTimestamps();
for (time = first, count = 0; time < max; time = +adapter.add(time, stepSize, minor), count++) {
addTick(ticks, time, timestamps);
}
if (time === max || options.bounds === "ticks" || count === 1) {
addTick(ticks, time, timestamps);
}
return Object.keys(ticks).sort(sorter).map((x2) => +x2);
}
getLabelForValue(value) {
const adapter = this._adapter;
const timeOpts = this.options.time;
if (timeOpts.tooltipFormat) {
return adapter.format(value, timeOpts.tooltipFormat);
}
return adapter.format(value, timeOpts.displayFormats.datetime);
}
format(value, format) {
const options = this.options;
const formats = options.time.displayFormats;
const unit = this._unit;
const fmt = format || formats[unit];
return this._adapter.format(value, fmt);
}
_tickFormatFunction(time, index, ticks, format) {
const options = this.options;
const formatter = options.ticks.callback;
if (formatter) {
return callback(formatter, [
time,
index,
ticks
], this);
}
const formats = options.time.displayFormats;
const unit = this._unit;
const majorUnit = this._majorUnit;
const minorFormat = unit && formats[unit];
const majorFormat = majorUnit && formats[majorUnit];
const tick = ticks[index];
const major = majorUnit && majorFormat && tick && tick.major;
return this._adapter.format(time, format || (major ? majorFormat : minorFormat));
}
generateTickLabels(ticks) {
let i2, ilen, tick;
for (i2 = 0, ilen = ticks.length; i2 < ilen; ++i2) {
tick = ticks[i2];
tick.label = this._tickFormatFunction(tick.value, i2, ticks);
}
}
getDecimalForValue(value) {
return value === null ? NaN : (value - this.min) / (this.max - this.min);
}
getPixelForValue(value) {
const offsets = this._offsets;
const pos = this.getDecimalForValue(value);
return this.getPixelForDecimal((offsets.start + pos) * offsets.factor);
}
getValueForPixel(pixel) {
const offsets = this._offsets;
const pos = this.getDecimalForPixel(pixel) / offsets.factor - offsets.end;
return this.min + pos * (this.max - this.min);
}
_getLabelSize(label) {
const ticksOpts = this.options.ticks;
const tickLabelWidth = this.ctx.measureText(label).width;
const angle = toRadians(this.isHorizontal() ? ticksOpts.maxRotation : ticksOpts.minRotation);
const cosRotation = Math.cos(angle);
const sinRotation = Math.sin(angle);
const tickFontSize = this._resolveTickFontOptions(0).size;
return {
w: tickLabelWidth * cosRotation + tickFontSize * sinRotation,
h: tickLabelWidth * sinRotation + tickFontSize * cosRotation
};
}
_getLabelCapacity(exampleTime) {
const timeOpts = this.options.time;
const displayFormats = timeOpts.displayFormats;
const format = displayFormats[timeOpts.unit] || displayFormats.millisecond;
const exampleLabel = this._tickFormatFunction(exampleTime, 0, ticksFromTimestamps(this, [
exampleTime
], this._majorUnit), format);
const size = this._getLabelSize(exampleLabel);
const capacity = Math.floor(this.isHorizontal() ? this.width / size.w : this.height / size.h) - 1;
return capacity > 0 ? capacity : 1;
}
getDataTimestamps() {
let timestamps = this._cache.data || [];
let i2, ilen;
if (timestamps.length) {
return timestamps;
}
const metas = this.getMatchingVisibleMetas();
if (this._normalized && metas.length) {
return this._cache.data = metas[0].controller.getAllParsedValues(this);
}
for (i2 = 0, ilen = metas.length; i2 < ilen; ++i2) {
timestamps = timestamps.concat(metas[i2].controller.getAllParsedValues(this));
}
return this._cache.data = this.normalize(timestamps);
}
getLabelTimestamps() {
const timestamps = this._cache.labels || [];
let i2, ilen;
if (timestamps.length) {
return timestamps;
}
const labels = this.getLabels();
for (i2 = 0, ilen = labels.length; i2 < ilen; ++i2) {
timestamps.push(parse2(this, labels[i2]));
}
return this._cache.labels = this._normalized ? timestamps : this.normalize(timestamps);
}
normalize(values) {
return _arrayUnique(values.sort(sorter));
}
};
__publicField(TimeScale, "id", "time");
__publicField(TimeScale, "defaults", {
bounds: "data",
adapters: {},
time: {
parser: false,
unit: false,
round: false,
isoWeekday: false,
minUnit: "millisecond",
displayFormats: {}
},
ticks: {
source: "auto",
callback: false,
major: {
enabled: false
}
}
});
function interpolate3(table, val, reverse) {
let lo = 0;
let hi = table.length - 1;
let prevSource, nextSource, prevTarget, nextTarget;
if (reverse) {
if (val >= table[lo].pos && val <= table[hi].pos) {
({ lo, hi } = _lookupByKey(table, "pos", val));
}
({ pos: prevSource, time: prevTarget } = table[lo]);
({ pos: nextSource, time: nextTarget } = table[hi]);
} else {
if (val >= table[lo].time && val <= table[hi].time) {
({ lo, hi } = _lookupByKey(table, "time", val));
}
({ time: prevSource, pos: prevTarget } = table[lo]);
({ time: nextSource, pos: nextTarget } = table[hi]);
}
const span = nextSource - prevSource;
return span ? prevTarget + (nextTarget - prevTarget) * (val - prevSource) / span : prevTarget;
}
var TimeSeriesScale = class extends TimeScale {
constructor(props) {
super(props);
this._table = [];
this._minPos = void 0;
this._tableRange = void 0;
}
initOffsets() {
const timestamps = this._getTimestampsForTable();
const table = this._table = this.buildLookupTable(timestamps);
this._minPos = interpolate3(table, this.min);
this._tableRange = interpolate3(table, this.max) - this._minPos;
super.initOffsets(timestamps);
}
buildLookupTable(timestamps) {
const { min, max } = this;
const items = [];
const table = [];
let i2, ilen, prev, curr, next;
for (i2 = 0, ilen = timestamps.length; i2 < ilen; ++i2) {
curr = timestamps[i2];
if (curr >= min && curr <= max) {
items.push(curr);
}
}
if (items.length < 2) {
return [
{
time: min,
pos: 0
},
{
time: max,
pos: 1
}
];
}
for (i2 = 0, ilen = items.length; i2 < ilen; ++i2) {
next = items[i2 + 1];
prev = items[i2 - 1];
curr = items[i2];
if (Math.round((next + prev) / 2) !== curr) {
table.push({
time: curr,
pos: i2 / (ilen - 1)
});
}
}
return table;
}
_generate() {
const min = this.min;
const max = this.max;
let timestamps = super.getDataTimestamps();
if (!timestamps.includes(min) || !timestamps.length) {
timestamps.splice(0, 0, min);
}
if (!timestamps.includes(max) || timestamps.length === 1) {
timestamps.push(max);
}
return timestamps.sort((a2, b2) => a2 - b2);
}
_getTimestampsForTable() {
let timestamps = this._cache.all || [];
if (timestamps.length) {
return timestamps;
}
const data = this.getDataTimestamps();
const label = this.getLabelTimestamps();
if (data.length && label.length) {
timestamps = this.normalize(data.concat(label));
} else {
timestamps = data.length ? data : label;
}
timestamps = this._cache.all = timestamps;
return timestamps;
}
getDecimalForValue(value) {
return (interpolate3(this._table, value) - this._minPos) / this._tableRange;
}
getValueForPixel(pixel) {
const offsets = this._offsets;
const decimal = this.getDecimalForPixel(pixel) / offsets.factor - offsets.end;
return interpolate3(this._table, decimal * this._tableRange + this._minPos, true);
}
};
__publicField(TimeSeriesScale, "id", "timeseries");
__publicField(TimeSeriesScale, "defaults", TimeScale.defaults);
// node_modules/.pnpm/gridjs@6.2.0/node_modules/gridjs/dist/gridjs.module.js
function t2(t3, n2) {
for (var e2 = 0; e2 < n2.length; e2++) {
var r2 = n2[e2];
r2.enumerable = r2.enumerable || false, r2.configurable = true, "value" in r2 && (r2.writable = true), Object.defineProperty(t3, "symbol" == typeof (o2 = function(t4, n3) {
if ("object" != typeof t4 || null === t4) return t4;
var e3 = t4[Symbol.toPrimitive];
if (void 0 !== e3) {
var r3 = e3.call(t4, "string");
if ("object" != typeof r3) return r3;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return String(t4);
}(r2.key)) ? o2 : String(o2), r2);
}
var o2;
}
function n(n2, e2, r2) {
return e2 && t2(n2.prototype, e2), r2 && t2(n2, r2), Object.defineProperty(n2, "prototype", { writable: false }), n2;
}
function e() {
return e = Object.assign ? Object.assign.bind() : function(t3) {
for (var n2 = 1; n2 < arguments.length; n2++) {
var e2 = arguments[n2];
for (var r2 in e2) Object.prototype.hasOwnProperty.call(e2, r2) && (t3[r2] = e2[r2]);
}
return t3;
}, e.apply(this, arguments);
}
function r(t3, n2) {
t3.prototype = Object.create(n2.prototype), t3.prototype.constructor = t3, o(t3, n2);
}
function o(t3, n2) {
return o = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t4, n3) {
return t4.__proto__ = n3, t4;
}, o(t3, n2);
}
function i(t3) {
if (void 0 === t3) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
return t3;
}
function u(t3, n2) {
(null == n2 || n2 > t3.length) && (n2 = t3.length);
for (var e2 = 0, r2 = new Array(n2); e2 < n2; e2++) r2[e2] = t3[e2];
return r2;
}
function s(t3, n2) {
var e2 = "undefined" != typeof Symbol && t3[Symbol.iterator] || t3["@@iterator"];
if (e2) return (e2 = e2.call(t3)).next.bind(e2);
if (Array.isArray(t3) || (e2 = function(t4, n3) {
if (t4) {
if ("string" == typeof t4) return u(t4, n3);
var e3 = Object.prototype.toString.call(t4).slice(8, -1);
return "Object" === e3 && t4.constructor && (e3 = t4.constructor.name), "Map" === e3 || "Set" === e3 ? Array.from(t4) : "Arguments" === e3 || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(e3) ? u(t4, n3) : void 0;
}
}(t3)) || n2 && t3 && "number" == typeof t3.length) {
e2 && (t3 = e2);
var r2 = 0;
return function() {
return r2 >= t3.length ? { done: true } : { done: false, value: t3[r2++] };
};
}
throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
var a;
!function(t3) {
t3[t3.Init = 0] = "Init", t3[t3.Loading = 1] = "Loading", t3[t3.Loaded = 2] = "Loaded", t3[t3.Rendered = 3] = "Rendered", t3[t3.Error = 4] = "Error";
}(a || (a = {}));
var l;
var c;
var f;
var p;
var d;
var h3;
var _;
var m = {};
var v = [];
var y = /acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i;
function g(t3, n2) {
for (var e2 in n2) t3[e2] = n2[e2];
return t3;
}
function b(t3) {
var n2 = t3.parentNode;
n2 && n2.removeChild(t3);
}
function w(t3, n2, e2) {
var r2, o2, i2, u2 = {};
for (i2 in n2) "key" == i2 ? r2 = n2[i2] : "ref" == i2 ? o2 = n2[i2] : u2[i2] = n2[i2];
if (arguments.length > 2 && (u2.children = arguments.length > 3 ? l.call(arguments, 2) : e2), "function" == typeof t3 && null != t3.defaultProps) for (i2 in t3.defaultProps) void 0 === u2[i2] && (u2[i2] = t3.defaultProps[i2]);
return x(t3, u2, r2, o2, null);
}
function x(t3, n2, e2, r2, o2) {
var i2 = { type: t3, props: n2, key: e2, ref: r2, __k: null, __: null, __b: 0, __e: null, __d: void 0, __c: null, __h: null, constructor: void 0, __v: null == o2 ? ++f : o2 };
return null == o2 && null != c.vnode && c.vnode(i2), i2;
}
function S(t3) {
return t3.children;
}
function N(t3, n2) {
this.props = t3, this.context = n2;
}
function P(t3, n2) {
if (null == n2) return t3.__ ? P(t3.__, t3.__.__k.indexOf(t3) + 1) : null;
for (var e2; n2 < t3.__k.length; n2++) if (null != (e2 = t3.__k[n2]) && null != e2.__e) return e2.__e;
return "function" == typeof t3.type ? P(t3) : null;
}
function C(t3) {
var n2, e2;
if (null != (t3 = t3.__) && null != t3.__c) {
for (t3.__e = t3.__c.base = null, n2 = 0; n2 < t3.__k.length; n2++) if (null != (e2 = t3.__k[n2]) && null != e2.__e) {
t3.__e = t3.__c.base = e2.__e;
break;
}
return C(t3);
}
}
function E(t3) {
(!t3.__d && (t3.__d = true) && d.push(t3) && !I.__r++ || h3 !== c.debounceRendering) && ((h3 = c.debounceRendering) || setTimeout)(I);
}
function I() {
for (var t3; I.__r = d.length; ) t3 = d.sort(function(t4, n2) {
return t4.__v.__b - n2.__v.__b;
}), d = [], t3.some(function(t4) {
var n2, e2, r2, o2, i2, u2;
t4.__d && (i2 = (o2 = (n2 = t4).__v).__e, (u2 = n2.__P) && (e2 = [], (r2 = g({}, o2)).__v = o2.__v + 1, M(u2, o2, r2, n2.__n, void 0 !== u2.ownerSVGElement, null != o2.__h ? [i2] : null, e2, null == i2 ? P(o2) : i2, o2.__h), F(e2, o2), o2.__e != i2 && C(o2)));
});
}
function T(t3, n2, e2, r2, o2, i2, u2, s2, a2, l2) {
var c2, f2, p2, d2, h6, _2, y2, g2 = r2 && r2.__k || v, b2 = g2.length;
for (e2.__k = [], c2 = 0; c2 < n2.length; c2++) if (null != (d2 = e2.__k[c2] = null == (d2 = n2[c2]) || "boolean" == typeof d2 ? null : "string" == typeof d2 || "number" == typeof d2 || "bigint" == typeof d2 ? x(null, d2, null, null, d2) : Array.isArray(d2) ? x(S, { children: d2 }, null, null, null) : d2.__b > 0 ? x(d2.type, d2.props, d2.key, d2.ref ? d2.ref : null, d2.__v) : d2)) {
if (d2.__ = e2, d2.__b = e2.__b + 1, null === (p2 = g2[c2]) || p2 && d2.key == p2.key && d2.type === p2.type) g2[c2] = void 0;
else for (f2 = 0; f2 < b2; f2++) {
if ((p2 = g2[f2]) && d2.key == p2.key && d2.type === p2.type) {
g2[f2] = void 0;
break;
}
p2 = null;
}
M(t3, d2, p2 = p2 || m, o2, i2, u2, s2, a2, l2), h6 = d2.__e, (f2 = d2.ref) && p2.ref != f2 && (y2 || (y2 = []), p2.ref && y2.push(p2.ref, null, d2), y2.push(f2, d2.__c || h6, d2)), null != h6 ? (null == _2 && (_2 = h6), "function" == typeof d2.type && d2.__k === p2.__k ? d2.__d = a2 = L(d2, a2, t3) : a2 = A(t3, d2, p2, g2, h6, a2), "function" == typeof e2.type && (e2.__d = a2)) : a2 && p2.__e == a2 && a2.parentNode != t3 && (a2 = P(p2));
}
for (e2.__e = _2, c2 = b2; c2--; ) null != g2[c2] && W(g2[c2], g2[c2]);
if (y2) for (c2 = 0; c2 < y2.length; c2++) U(y2[c2], y2[++c2], y2[++c2]);
}
function L(t3, n2, e2) {
for (var r2, o2 = t3.__k, i2 = 0; o2 && i2 < o2.length; i2++) (r2 = o2[i2]) && (r2.__ = t3, n2 = "function" == typeof r2.type ? L(r2, n2, e2) : A(e2, r2, r2, o2, r2.__e, n2));
return n2;
}
function A(t3, n2, e2, r2, o2, i2) {
var u2, s2, a2;
if (void 0 !== n2.__d) u2 = n2.__d, n2.__d = void 0;
else if (null == e2 || o2 != i2 || null == o2.parentNode) t: if (null == i2 || i2.parentNode !== t3) t3.appendChild(o2), u2 = null;
else {
for (s2 = i2, a2 = 0; (s2 = s2.nextSibling) && a2 < r2.length; a2 += 1) if (s2 == o2) break t;
t3.insertBefore(o2, i2), u2 = i2;
}
return void 0 !== u2 ? u2 : o2.nextSibling;
}
function O(t3, n2, e2) {
"-" === n2[0] ? t3.setProperty(n2, e2) : t3[n2] = null == e2 ? "" : "number" != typeof e2 || y.test(n2) ? e2 : e2 + "px";
}
function H(t3, n2, e2, r2, o2) {
var i2;
t: if ("style" === n2) if ("string" == typeof e2) t3.style.cssText = e2;
else {
if ("string" == typeof r2 && (t3.style.cssText = r2 = ""), r2) for (n2 in r2) e2 && n2 in e2 || O(t3.style, n2, "");
if (e2) for (n2 in e2) r2 && e2[n2] === r2[n2] || O(t3.style, n2, e2[n2]);
}
else if ("o" === n2[0] && "n" === n2[1]) i2 = n2 !== (n2 = n2.replace(/Capture$/, "")), n2 = n2.toLowerCase() in t3 ? n2.toLowerCase().slice(2) : n2.slice(2), t3.l || (t3.l = {}), t3.l[n2 + i2] = e2, e2 ? r2 || t3.addEventListener(n2, i2 ? D : j, i2) : t3.removeEventListener(n2, i2 ? D : j, i2);
else if ("dangerouslySetInnerHTML" !== n2) {
if (o2) n2 = n2.replace(/xlink(H|:h)/, "h").replace(/sName$/, "s");
else if ("href" !== n2 && "list" !== n2 && "form" !== n2 && "tabIndex" !== n2 && "download" !== n2 && n2 in t3) try {
t3[n2] = null == e2 ? "" : e2;
break t;
} catch (t4) {
}
"function" == typeof e2 || (null == e2 || false === e2 && -1 == n2.indexOf("-") ? t3.removeAttribute(n2) : t3.setAttribute(n2, e2));
}
}
function j(t3) {
this.l[t3.type + false](c.event ? c.event(t3) : t3);
}
function D(t3) {
this.l[t3.type + true](c.event ? c.event(t3) : t3);
}
function M(t3, n2, e2, r2, o2, i2, u2, s2, a2) {
var l2, f2, p2, d2, h6, _2, m2, v2, y2, b2, w2, x2, k, P2, C2, E2 = n2.type;
if (void 0 !== n2.constructor) return null;
null != e2.__h && (a2 = e2.__h, s2 = n2.__e = e2.__e, n2.__h = null, i2 = [s2]), (l2 = c.__b) && l2(n2);
try {
t: if ("function" == typeof E2) {
if (v2 = n2.props, y2 = (l2 = E2.contextType) && r2[l2.__c], b2 = l2 ? y2 ? y2.props.value : l2.__ : r2, e2.__c ? m2 = (f2 = n2.__c = e2.__c).__ = f2.__E : ("prototype" in E2 && E2.prototype.render ? n2.__c = f2 = new E2(v2, b2) : (n2.__c = f2 = new N(v2, b2), f2.constructor = E2, f2.render = B), y2 && y2.sub(f2), f2.props = v2, f2.state || (f2.state = {}), f2.context = b2, f2.__n = r2, p2 = f2.__d = true, f2.__h = [], f2._sb = []), null == f2.__s && (f2.__s = f2.state), null != E2.getDerivedStateFromProps && (f2.__s == f2.state && (f2.__s = g({}, f2.__s)), g(f2.__s, E2.getDerivedStateFromProps(v2, f2.__s))), d2 = f2.props, h6 = f2.state, p2) null == E2.getDerivedStateFromProps && null != f2.componentWillMount && f2.componentWillMount(), null != f2.componentDidMount && f2.__h.push(f2.componentDidMount);
else {
if (null == E2.getDerivedStateFromProps && v2 !== d2 && null != f2.componentWillReceiveProps && f2.componentWillReceiveProps(v2, b2), !f2.__e && null != f2.shouldComponentUpdate && false === f2.shouldComponentUpdate(v2, f2.__s, b2) || n2.__v === e2.__v) {
for (f2.props = v2, f2.state = f2.__s, n2.__v !== e2.__v && (f2.__d = false), f2.__v = n2, n2.__e = e2.__e, n2.__k = e2.__k, n2.__k.forEach(function(t4) {
t4 && (t4.__ = n2);
}), w2 = 0; w2 < f2._sb.length; w2++) f2.__h.push(f2._sb[w2]);
f2._sb = [], f2.__h.length && u2.push(f2);
break t;
}
null != f2.componentWillUpdate && f2.componentWillUpdate(v2, f2.__s, b2), null != f2.componentDidUpdate && f2.__h.push(function() {
f2.componentDidUpdate(d2, h6, _2);
});
}
if (f2.context = b2, f2.props = v2, f2.__v = n2, f2.__P = t3, x2 = c.__r, k = 0, "prototype" in E2 && E2.prototype.render) {
for (f2.state = f2.__s, f2.__d = false, x2 && x2(n2), l2 = f2.render(f2.props, f2.state, f2.context), P2 = 0; P2 < f2._sb.length; P2++) f2.__h.push(f2._sb[P2]);
f2._sb = [];
} else do {
f2.__d = false, x2 && x2(n2), l2 = f2.render(f2.props, f2.state, f2.context), f2.state = f2.__s;
} while (f2.__d && ++k < 25);
f2.state = f2.__s, null != f2.getChildContext && (r2 = g(g({}, r2), f2.getChildContext())), p2 || null == f2.getSnapshotBeforeUpdate || (_2 = f2.getSnapshotBeforeUpdate(d2, h6)), C2 = null != l2 && l2.type === S && null == l2.key ? l2.props.children : l2, T(t3, Array.isArray(C2) ? C2 : [C2], n2, e2, r2, o2, i2, u2, s2, a2), f2.base = n2.__e, n2.__h = null, f2.__h.length && u2.push(f2), m2 && (f2.__E = f2.__ = null), f2.__e = false;
} else null == i2 && n2.__v === e2.__v ? (n2.__k = e2.__k, n2.__e = e2.__e) : n2.__e = R(e2.__e, n2, e2, r2, o2, i2, u2, a2);
(l2 = c.diffed) && l2(n2);
} catch (t4) {
n2.__v = null, (a2 || null != i2) && (n2.__e = s2, n2.__h = !!a2, i2[i2.indexOf(s2)] = null), c.__e(t4, n2, e2);
}
}
function F(t3, n2) {
c.__c && c.__c(n2, t3), t3.some(function(n3) {
try {
t3 = n3.__h, n3.__h = [], t3.some(function(t4) {
t4.call(n3);
});
} catch (t4) {
c.__e(t4, n3.__v);
}
});
}
function R(t3, n2, e2, r2, o2, i2, u2, s2) {
var a2, c2, f2, p2 = e2.props, d2 = n2.props, h6 = n2.type, _2 = 0;
if ("svg" === h6 && (o2 = true), null != i2) {
for (; _2 < i2.length; _2++) if ((a2 = i2[_2]) && "setAttribute" in a2 == !!h6 && (h6 ? a2.localName === h6 : 3 === a2.nodeType)) {
t3 = a2, i2[_2] = null;
break;
}
}
if (null == t3) {
if (null === h6) return document.createTextNode(d2);
t3 = o2 ? document.createElementNS("http://www.w3.org/2000/svg", h6) : document.createElement(h6, d2.is && d2), i2 = null, s2 = false;
}
if (null === h6) p2 === d2 || s2 && t3.data === d2 || (t3.data = d2);
else {
if (i2 = i2 && l.call(t3.childNodes), c2 = (p2 = e2.props || m).dangerouslySetInnerHTML, f2 = d2.dangerouslySetInnerHTML, !s2) {
if (null != i2) for (p2 = {}, _2 = 0; _2 < t3.attributes.length; _2++) p2[t3.attributes[_2].name] = t3.attributes[_2].value;
(f2 || c2) && (f2 && (c2 && f2.__html == c2.__html || f2.__html === t3.innerHTML) || (t3.innerHTML = f2 && f2.__html || ""));
}
if (function(t4, n3, e3, r3, o3) {
var i3;
for (i3 in e3) "children" === i3 || "key" === i3 || i3 in n3 || H(t4, i3, null, e3[i3], r3);
for (i3 in n3) o3 && "function" != typeof n3[i3] || "children" === i3 || "key" === i3 || "value" === i3 || "checked" === i3 || e3[i3] === n3[i3] || H(t4, i3, n3[i3], e3[i3], r3);
}(t3, d2, p2, o2, s2), f2) n2.__k = [];
else if (_2 = n2.props.children, T(t3, Array.isArray(_2) ? _2 : [_2], n2, e2, r2, o2 && "foreignObject" !== h6, i2, u2, i2 ? i2[0] : e2.__k && P(e2, 0), s2), null != i2) for (_2 = i2.length; _2--; ) null != i2[_2] && b(i2[_2]);
s2 || ("value" in d2 && void 0 !== (_2 = d2.value) && (_2 !== t3.value || "progress" === h6 && !_2 || "option" === h6 && _2 !== p2.value) && H(t3, "value", _2, p2.value, false), "checked" in d2 && void 0 !== (_2 = d2.checked) && _2 !== t3.checked && H(t3, "checked", _2, p2.checked, false));
}
return t3;
}
function U(t3, n2, e2) {
try {
"function" == typeof t3 ? t3(n2) : t3.current = n2;
} catch (t4) {
c.__e(t4, e2);
}
}
function W(t3, n2, e2) {
var r2, o2;
if (c.unmount && c.unmount(t3), (r2 = t3.ref) && (r2.current && r2.current !== t3.__e || U(r2, null, n2)), null != (r2 = t3.__c)) {
if (r2.componentWillUnmount) try {
r2.componentWillUnmount();
} catch (t4) {
c.__e(t4, n2);
}
r2.base = r2.__P = null, t3.__c = void 0;
}
if (r2 = t3.__k) for (o2 = 0; o2 < r2.length; o2++) r2[o2] && W(r2[o2], n2, e2 || "function" != typeof t3.type);
e2 || null == t3.__e || b(t3.__e), t3.__ = t3.__e = t3.__d = void 0;
}
function B(t3, n2, e2) {
return this.constructor(t3, e2);
}
function q(t3, n2, e2) {
var r2, o2, i2;
c.__ && c.__(t3, n2), o2 = (r2 = "function" == typeof e2) ? null : e2 && e2.__k || n2.__k, i2 = [], M(n2, t3 = (!r2 && e2 || n2).__k = w(S, null, [t3]), o2 || m, m, void 0 !== n2.ownerSVGElement, !r2 && e2 ? [e2] : o2 ? null : n2.firstChild ? l.call(n2.childNodes) : null, i2, !r2 && e2 ? e2 : o2 ? o2.__e : n2.firstChild, r2), F(i2, t3);
}
function z() {
return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(t3) {
var n2 = 16 * Math.random() | 0;
return ("x" == t3 ? n2 : 3 & n2 | 8).toString(16);
});
}
l = v.slice, c = { __e: function(t3, n2, e2, r2) {
for (var o2, i2, u2; n2 = n2.__; ) if ((o2 = n2.__c) && !o2.__) try {
if ((i2 = o2.constructor) && null != i2.getDerivedStateFromError && (o2.setState(i2.getDerivedStateFromError(t3)), u2 = o2.__d), null != o2.componentDidCatch && (o2.componentDidCatch(t3, r2 || {}), u2 = o2.__d), u2) return o2.__E = o2;
} catch (n3) {
t3 = n3;
}
throw t3;
} }, f = 0, p = function(t3) {
return null != t3 && void 0 === t3.constructor;
}, N.prototype.setState = function(t3, n2) {
var e2;
e2 = null != this.__s && this.__s !== this.state ? this.__s : this.__s = g({}, this.state), "function" == typeof t3 && (t3 = t3(g({}, e2), this.props)), t3 && g(e2, t3), null != t3 && this.__v && (n2 && this._sb.push(n2), E(this));
}, N.prototype.forceUpdate = function(t3) {
this.__v && (this.__e = true, t3 && this.__h.push(t3), E(this));
}, N.prototype.render = S, d = [], I.__r = 0, _ = 0;
var V = /* @__PURE__ */ function() {
function t3(t4) {
this._id = void 0, this._id = t4 || z();
}
return n(t3, [{ key: "id", get: function() {
return this._id;
} }]), t3;
}();
function $(t3) {
return w(t3.parentElement || "span", { dangerouslySetInnerHTML: { __html: t3.content } });
}
function G(t3, n2) {
return w($, { content: t3, parentElement: n2 });
}
var K;
var X = /* @__PURE__ */ function(t3) {
function n2(n3) {
var e3;
return (e3 = t3.call(this) || this).data = void 0, e3.update(n3), e3;
}
r(n2, t3);
var e2 = n2.prototype;
return e2.cast = function(t4) {
return t4 instanceof HTMLElement ? G(t4.outerHTML) : t4;
}, e2.update = function(t4) {
return this.data = this.cast(t4), this;
}, n2;
}(V);
var Z = /* @__PURE__ */ function(t3) {
function e2(n2) {
var e3;
return (e3 = t3.call(this) || this)._cells = void 0, e3.cells = n2 || [], e3;
}
r(e2, t3);
var o2 = e2.prototype;
return o2.cell = function(t4) {
return this._cells[t4];
}, o2.toArray = function() {
return this.cells.map(function(t4) {
return t4.data;
});
}, e2.fromCells = function(t4) {
return new e2(t4.map(function(t5) {
return new X(t5.data);
}));
}, n(e2, [{ key: "cells", get: function() {
return this._cells;
}, set: function(t4) {
this._cells = t4;
} }, { key: "length", get: function() {
return this.cells.length;
} }]), e2;
}(V);
var J = /* @__PURE__ */ function(t3) {
function e2(n2) {
var e3;
return (e3 = t3.call(this) || this)._rows = void 0, e3._length = void 0, e3.rows = n2 instanceof Array ? n2 : n2 instanceof Z ? [n2] : [], e3;
}
return r(e2, t3), e2.prototype.toArray = function() {
return this.rows.map(function(t4) {
return t4.toArray();
});
}, e2.fromRows = function(t4) {
return new e2(t4.map(function(t5) {
return Z.fromCells(t5.cells);
}));
}, e2.fromArray = function(t4) {
return new e2((t4 = function(t5) {
return !t5[0] || t5[0] instanceof Array ? t5 : [t5];
}(t4)).map(function(t5) {
return new Z(t5.map(function(t6) {
return new X(t6);
}));
}));
}, n(e2, [{ key: "rows", get: function() {
return this._rows;
}, set: function(t4) {
this._rows = t4;
} }, { key: "length", get: function() {
return this._length || this.rows.length;
}, set: function(t4) {
this._length = t4;
} }]), e2;
}(V);
var Q = /* @__PURE__ */ function() {
function t3() {
this.callbacks = void 0;
}
var n2 = t3.prototype;
return n2.init = function(t4) {
this.callbacks || (this.callbacks = {}), t4 && !this.callbacks[t4] && (this.callbacks[t4] = []);
}, n2.listeners = function() {
return this.callbacks;
}, n2.on = function(t4, n3) {
return this.init(t4), this.callbacks[t4].push(n3), this;
}, n2.off = function(t4, n3) {
var e2 = t4;
return this.init(), this.callbacks[e2] && 0 !== this.callbacks[e2].length ? (this.callbacks[e2] = this.callbacks[e2].filter(function(t5) {
return t5 != n3;
}), this) : this;
}, n2.emit = function(t4) {
var n3 = arguments, e2 = t4;
return this.init(e2), this.callbacks[e2].length > 0 && (this.callbacks[e2].forEach(function(t5) {
return t5.apply(void 0, [].slice.call(n3, 1));
}), true);
}, t3;
}();
function Y(t3, n2) {
if (typeof t3 != typeof n2) return false;
if (null === t3 && null === n2) return true;
if ("object" != typeof t3) return t3 === n2;
if (Array.isArray(t3) && Array.isArray(n2)) {
if (t3.length !== n2.length) return false;
for (var e2 = 0; e2 < t3.length; e2++) if (!Y(t3[e2], n2[e2])) return false;
return true;
}
if (t3.hasOwnProperty("constructor") && n2.hasOwnProperty("constructor") && t3.hasOwnProperty("props") && n2.hasOwnProperty("props") && t3.hasOwnProperty("key") && n2.hasOwnProperty("key") && t3.hasOwnProperty("ref") && n2.hasOwnProperty("ref") && t3.hasOwnProperty("type") && n2.hasOwnProperty("type")) return Y(t3.props, n2.props);
var r2 = Object.keys(t3), o2 = Object.keys(n2);
if (r2.length !== o2.length) return false;
for (var i2 = 0, u2 = r2; i2 < u2.length; i2++) {
var s2 = u2[i2];
if (!n2.hasOwnProperty(s2) || !Y(t3[s2], n2[s2])) return false;
}
return true;
}
!function(t3) {
t3[t3.Initiator = 0] = "Initiator", t3[t3.ServerFilter = 1] = "ServerFilter", t3[t3.ServerSort = 2] = "ServerSort", t3[t3.ServerLimit = 3] = "ServerLimit", t3[t3.Extractor = 4] = "Extractor", t3[t3.Transformer = 5] = "Transformer", t3[t3.Filter = 6] = "Filter", t3[t3.Sort = 7] = "Sort", t3[t3.Limit = 8] = "Limit";
}(K || (K = {}));
var tt = /* @__PURE__ */ function(t3) {
function o2(n2) {
var e2;
return (e2 = t3.call(this) || this).id = void 0, e2._props = void 0, e2._props = {}, e2.id = z(), n2 && e2.setProps(n2), e2;
}
r(o2, t3);
var i2 = o2.prototype;
return i2.process = function() {
var t4 = [].slice.call(arguments);
this.validateProps instanceof Function && this.validateProps.apply(this, t4), this.emit.apply(this, ["beforeProcess"].concat(t4));
var n2 = this._process.apply(this, t4);
return this.emit.apply(this, ["afterProcess"].concat(t4)), n2;
}, i2.setProps = function(t4) {
var n2 = e({}, this._props, t4);
return Y(n2, this._props) || (this._props = n2, this.emit("propsUpdated", this)), this;
}, n(o2, [{ key: "props", get: function() {
return this._props;
} }]), o2;
}(Q);
var nt = /* @__PURE__ */ function(t3) {
function e2() {
return t3.apply(this, arguments) || this;
}
return r(e2, t3), e2.prototype._process = function(t4) {
return this.props.keyword ? (n2 = String(this.props.keyword).trim(), e3 = this.props.columns, r2 = this.props.ignoreHiddenColumns, o2 = t4, i2 = this.props.selector, n2 = n2.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), new J(o2.rows.filter(function(t5, o3) {
return t5.cells.some(function(t6, u2) {
if (!t6) return false;
if (r2 && e3 && e3[u2] && "object" == typeof e3[u2] && e3[u2].hidden) return false;
var s2 = "";
if ("function" == typeof i2) s2 = i2(t6.data, o3, u2);
else if ("object" == typeof t6.data) {
var a2 = t6.data;
a2 && a2.props && a2.props.content && (s2 = a2.props.content);
} else s2 = String(t6.data);
return new RegExp(n2, "gi").test(s2);
});
}))) : t4;
var n2, e3, r2, o2, i2;
}, n(e2, [{ key: "type", get: function() {
return K.Filter;
} }]), e2;
}(tt);
function et() {
var t3 = "gridjs";
return "" + t3 + [].slice.call(arguments).reduce(function(t4, n2) {
return t4 + "-" + n2;
}, "");
}
function rt() {
return [].slice.call(arguments).map(function(t3) {
return t3 ? t3.toString() : "";
}).filter(function(t3) {
return t3;
}).reduce(function(t3, n2) {
return (t3 || "") + " " + n2;
}, "").trim();
}
var ot;
var it;
var ut;
var st;
var at = /* @__PURE__ */ function(t3) {
function o2() {
return t3.apply(this, arguments) || this;
}
return r(o2, t3), o2.prototype._process = function(t4) {
if (!this.props.keyword) return t4;
var n2 = {};
return this.props.url && (n2.url = this.props.url(t4.url, this.props.keyword)), this.props.body && (n2.body = this.props.body(t4.body, this.props.keyword)), e({}, t4, n2);
}, n(o2, [{ key: "type", get: function() {
return K.ServerFilter;
} }]), o2;
}(tt);
var lt = 0;
var ct = [];
var ft = [];
var pt = c.__b;
var dt = c.__r;
var ht = c.diffed;
var _t = c.__c;
var mt = c.unmount;
function vt(t3, n2) {
c.__h && c.__h(it, t3, lt || n2), lt = 0;
var e2 = it.__H || (it.__H = { __: [], __h: [] });
return t3 >= e2.__.length && e2.__.push({ __V: ft }), e2.__[t3];
}
function yt(t3) {
return lt = 1, function(t4, n2, e2) {
var r2 = vt(ot++, 2);
if (r2.t = t4, !r2.__c && (r2.__ = [Et(void 0, n2), function(t5) {
var n3 = r2.__N ? r2.__N[0] : r2.__[0], e3 = r2.t(n3, t5);
n3 !== e3 && (r2.__N = [e3, r2.__[1]], r2.__c.setState({}));
}], r2.__c = it, !it.u)) {
it.u = true;
var o2 = it.shouldComponentUpdate;
it.shouldComponentUpdate = function(t5, n3, e3) {
if (!r2.__c.__H) return true;
var i2 = r2.__c.__H.__.filter(function(t6) {
return t6.__c;
});
if (i2.every(function(t6) {
return !t6.__N;
})) return !o2 || o2.call(this, t5, n3, e3);
var u2 = false;
return i2.forEach(function(t6) {
if (t6.__N) {
var n4 = t6.__[0];
t6.__ = t6.__N, t6.__N = void 0, n4 !== t6.__[0] && (u2 = true);
}
}), !(!u2 && r2.__c.props === t5) && (!o2 || o2.call(this, t5, n3, e3));
};
}
return r2.__N || r2.__;
}(Et, t3);
}
function gt(t3, n2) {
var e2 = vt(ot++, 3);
!c.__s && Ct(e2.__H, n2) && (e2.__ = t3, e2.i = n2, it.__H.__h.push(e2));
}
function bt(t3) {
return lt = 5, wt(function() {
return { current: t3 };
}, []);
}
function wt(t3, n2) {
var e2 = vt(ot++, 7);
return Ct(e2.__H, n2) ? (e2.__V = t3(), e2.i = n2, e2.__h = t3, e2.__V) : e2.__;
}
function xt() {
for (var t3; t3 = ct.shift(); ) if (t3.__P && t3.__H) try {
t3.__H.__h.forEach(Nt), t3.__H.__h.forEach(Pt), t3.__H.__h = [];
} catch (n2) {
t3.__H.__h = [], c.__e(n2, t3.__v);
}
}
c.__b = function(t3) {
it = null, pt && pt(t3);
}, c.__r = function(t3) {
dt && dt(t3), ot = 0;
var n2 = (it = t3.__c).__H;
n2 && (ut === it ? (n2.__h = [], it.__h = [], n2.__.forEach(function(t4) {
t4.__N && (t4.__ = t4.__N), t4.__V = ft, t4.__N = t4.i = void 0;
})) : (n2.__h.forEach(Nt), n2.__h.forEach(Pt), n2.__h = [])), ut = it;
}, c.diffed = function(t3) {
ht && ht(t3);
var n2 = t3.__c;
n2 && n2.__H && (n2.__H.__h.length && (1 !== ct.push(n2) && st === c.requestAnimationFrame || ((st = c.requestAnimationFrame) || St)(xt)), n2.__H.__.forEach(function(t4) {
t4.i && (t4.__H = t4.i), t4.__V !== ft && (t4.__ = t4.__V), t4.i = void 0, t4.__V = ft;
})), ut = it = null;
}, c.__c = function(t3, n2) {
n2.some(function(t4) {
try {
t4.__h.forEach(Nt), t4.__h = t4.__h.filter(function(t5) {
return !t5.__ || Pt(t5);
});
} catch (e2) {
n2.some(function(t5) {
t5.__h && (t5.__h = []);
}), n2 = [], c.__e(e2, t4.__v);
}
}), _t && _t(t3, n2);
}, c.unmount = function(t3) {
mt && mt(t3);
var n2, e2 = t3.__c;
e2 && e2.__H && (e2.__H.__.forEach(function(t4) {
try {
Nt(t4);
} catch (t5) {
n2 = t5;
}
}), e2.__H = void 0, n2 && c.__e(n2, e2.__v));
};
var kt = "function" == typeof requestAnimationFrame;
function St(t3) {
var n2, e2 = function() {
clearTimeout(r2), kt && cancelAnimationFrame(n2), setTimeout(t3);
}, r2 = setTimeout(e2, 100);
kt && (n2 = requestAnimationFrame(e2));
}
function Nt(t3) {
var n2 = it, e2 = t3.__c;
"function" == typeof e2 && (t3.__c = void 0, e2()), it = n2;
}
function Pt(t3) {
var n2 = it;
t3.__c = t3.__(), it = n2;
}
function Ct(t3, n2) {
return !t3 || t3.length !== n2.length || n2.some(function(n3, e2) {
return n3 !== t3[e2];
});
}
function Et(t3, n2) {
return "function" == typeof n2 ? n2(t3) : n2;
}
function It() {
return function(t3) {
var n2 = it.context[t3.__c], e2 = vt(ot++, 9);
return e2.c = t3, n2 ? (null == e2.__ && (e2.__ = true, n2.sub(it)), n2.props.value) : t3.__;
}(fn);
}
var Tt = { search: { placeholder: "Type a keyword..." }, sort: { sortAsc: "Sort column ascending", sortDesc: "Sort column descending" }, pagination: { previous: "Previous", next: "Next", navigate: function(t3, n2) {
return "Page " + t3 + " of " + n2;
}, page: function(t3) {
return "Page " + t3;
}, showing: "Showing", of: "of", to: "to", results: "results" }, loading: "Loading...", noRecordsFound: "No matching records found", error: "An error happened while fetching the data" };
var Lt = /* @__PURE__ */ function() {
function t3(t4) {
this._language = void 0, this._defaultLanguage = void 0, this._language = t4, this._defaultLanguage = Tt;
}
var n2 = t3.prototype;
return n2.getString = function(t4, n3) {
if (!n3 || !t4) return null;
var e2 = t4.split("."), r2 = e2[0];
if (n3[r2]) {
var o2 = n3[r2];
return "string" == typeof o2 ? function() {
return o2;
} : "function" == typeof o2 ? o2 : this.getString(e2.slice(1).join("."), o2);
}
return null;
}, n2.translate = function(t4) {
var n3, e2 = this.getString(t4, this._language);
return (n3 = e2 || this.getString(t4, this._defaultLanguage)) ? n3.apply(void 0, [].slice.call(arguments, 1)) : t4;
}, t3;
}();
function At() {
var t3 = It();
return function(n2) {
var e2;
return (e2 = t3.translator).translate.apply(e2, [n2].concat([].slice.call(arguments, 1)));
};
}
var Ot = function(t3) {
return function(n2) {
return e({}, n2, { search: { keyword: t3 } });
};
};
function Ht() {
return It().store;
}
function jt(t3) {
var n2 = Ht(), e2 = yt(t3(n2.getState())), r2 = e2[0], o2 = e2[1];
return gt(function() {
return n2.subscribe(function() {
var e3 = t3(n2.getState());
r2 !== e3 && o2(e3);
});
}, []), r2;
}
function Dt() {
var t3, n2 = yt(void 0), e2 = n2[0], r2 = n2[1], o2 = It(), i2 = o2.search, u2 = At(), s2 = Ht().dispatch, a2 = jt(function(t4) {
return t4.search;
});
gt(function() {
e2 && e2.setProps({ keyword: null == a2 ? void 0 : a2.keyword });
}, [a2, e2]), gt(function() {
r2(i2.server ? new at({ keyword: i2.keyword, url: i2.server.url, body: i2.server.body }) : new nt({ keyword: i2.keyword, columns: o2.header && o2.header.columns, ignoreHiddenColumns: i2.ignoreHiddenColumns || void 0 === i2.ignoreHiddenColumns, selector: i2.selector })), i2.keyword && s2(Ot(i2.keyword));
}, [i2]), gt(function() {
if (e2) return o2.pipeline.register(e2), function() {
return o2.pipeline.unregister(e2);
};
}, [o2, e2]);
var l2, c2, f2, p2 = function(t4, n3) {
return lt = 8, wt(function() {
return t4;
}, n3);
}((l2 = function(t4) {
t4.target instanceof HTMLInputElement && s2(Ot(t4.target.value));
}, c2 = e2 instanceof at ? i2.debounceTimeout || 250 : 0, function() {
var t4 = arguments;
return new Promise(function(n3) {
f2 && clearTimeout(f2), f2 = setTimeout(function() {
return n3(l2.apply(void 0, [].slice.call(t4)));
}, c2);
});
}), [i2, e2]);
return w("div", { className: et(rt("search", null == (t3 = o2.className) ? void 0 : t3.search)) }, w("input", { type: "search", placeholder: u2("search.placeholder"), "aria-label": u2("search.placeholder"), onInput: p2, className: rt(et("input"), et("search", "input")), defaultValue: (null == a2 ? void 0 : a2.keyword) || "" }));
}
var Mt = /* @__PURE__ */ function(t3) {
function e2() {
return t3.apply(this, arguments) || this;
}
r(e2, t3);
var o2 = e2.prototype;
return o2.validateProps = function() {
if (isNaN(Number(this.props.limit)) || isNaN(Number(this.props.page))) throw Error("Invalid parameters passed");
}, o2._process = function(t4) {
var n2 = this.props.page;
return new J(t4.rows.slice(n2 * this.props.limit, (n2 + 1) * this.props.limit));
}, n(e2, [{ key: "type", get: function() {
return K.Limit;
} }]), e2;
}(tt);
var Ft = /* @__PURE__ */ function(t3) {
function o2() {
return t3.apply(this, arguments) || this;
}
return r(o2, t3), o2.prototype._process = function(t4) {
var n2 = {};
return this.props.url && (n2.url = this.props.url(t4.url, this.props.page, this.props.limit)), this.props.body && (n2.body = this.props.body(t4.body, this.props.page, this.props.limit)), e({}, t4, n2);
}, n(o2, [{ key: "type", get: function() {
return K.ServerLimit;
} }]), o2;
}(tt);
function Rt() {
var t3 = It(), n2 = t3.pagination, e2 = n2.server, r2 = n2.summary, o2 = void 0 === r2 || r2, i2 = n2.nextButton, u2 = void 0 === i2 || i2, s2 = n2.prevButton, a2 = void 0 === s2 || s2, l2 = n2.buttonsCount, c2 = void 0 === l2 ? 3 : l2, f2 = n2.limit, p2 = void 0 === f2 ? 10 : f2, d2 = n2.page, h6 = void 0 === d2 ? 0 : d2, _2 = n2.resetPageOnUpdate, m2 = void 0 === _2 || _2, v2 = bt(null), y2 = yt(h6), g2 = y2[0], b2 = y2[1], x2 = yt(0), k = x2[0], N2 = x2[1], P2 = At();
gt(function() {
return e2 ? (v2.current = new Ft({ limit: p2, page: g2, url: e2.url, body: e2.body }), t3.pipeline.register(v2.current)) : (v2.current = new Mt({ limit: p2, page: g2 }), t3.pipeline.register(v2.current)), v2.current instanceof Ft ? t3.pipeline.on("afterProcess", function(t4) {
return N2(t4.length);
}) : v2.current instanceof Mt && v2.current.on("beforeProcess", function(t4) {
return N2(t4.length);
}), t3.pipeline.on("updated", C2), t3.pipeline.on("error", function() {
N2(0), b2(0);
}), function() {
t3.pipeline.unregister(v2.current), t3.pipeline.off("updated", C2);
};
}, []);
var C2 = function(t4) {
m2 && t4 !== v2.current && (b2(0), 0 !== v2.current.props.page && v2.current.setProps({ page: 0 }));
}, E2 = function() {
return Math.ceil(k / p2);
}, I2 = function(t4) {
if (t4 >= E2() || t4 < 0 || t4 === g2) return null;
b2(t4), v2.current.setProps({ page: t4 });
};
return w("div", { className: rt(et("pagination"), t3.className.pagination) }, w(S, null, o2 && k > 0 && w("div", { role: "status", "aria-live": "polite", className: rt(et("summary"), t3.className.paginationSummary), title: P2("pagination.navigate", g2 + 1, E2()) }, P2("pagination.showing"), " ", w("b", null, P2("" + (g2 * p2 + 1))), " ", P2("pagination.to"), " ", w("b", null, P2("" + Math.min((g2 + 1) * p2, k))), " ", P2("pagination.of"), " ", w("b", null, P2("" + k)), " ", P2("pagination.results"))), w("div", { className: et("pages") }, a2 && w("button", { tabIndex: 0, role: "button", disabled: 0 === g2, onClick: function() {
return I2(g2 - 1);
}, title: P2("pagination.previous"), "aria-label": P2("pagination.previous"), className: rt(t3.className.paginationButton, t3.className.paginationButtonPrev) }, P2("pagination.previous")), function() {
if (c2 <= 0) return null;
var n3 = Math.min(E2(), c2), e3 = Math.min(g2, Math.floor(n3 / 2));
return g2 + Math.floor(n3 / 2) >= E2() && (e3 = n3 - (E2() - g2)), w(S, null, E2() > n3 && g2 - e3 > 0 && w(S, null, w("button", { tabIndex: 0, role: "button", onClick: function() {
return I2(0);
}, title: P2("pagination.firstPage"), "aria-label": P2("pagination.firstPage"), className: t3.className.paginationButton }, P2("1")), w("button", { tabIndex: -1, className: rt(et("spread"), t3.className.paginationButton) }, "...")), Array.from(Array(n3).keys()).map(function(t4) {
return g2 + (t4 - e3);
}).map(function(n4) {
return w("button", { tabIndex: 0, role: "button", onClick: function() {
return I2(n4);
}, className: rt(g2 === n4 ? rt(et("currentPage"), t3.className.paginationButtonCurrent) : null, t3.className.paginationButton), title: P2("pagination.page", n4 + 1), "aria-label": P2("pagination.page", n4 + 1) }, P2("" + (n4 + 1)));
}), E2() > n3 && E2() > g2 + e3 + 1 && w(S, null, w("button", { tabIndex: -1, className: rt(et("spread"), t3.className.paginationButton) }, "..."), w("button", { tabIndex: 0, role: "button", onClick: function() {
return I2(E2() - 1);
}, title: P2("pagination.page", E2()), "aria-label": P2("pagination.page", E2()), className: t3.className.paginationButton }, P2("" + E2()))));
}(), u2 && w("button", { tabIndex: 0, role: "button", disabled: E2() === g2 + 1 || 0 === E2(), onClick: function() {
return I2(g2 + 1);
}, title: P2("pagination.next"), "aria-label": P2("pagination.next"), className: rt(t3.className.paginationButton, t3.className.paginationButtonNext) }, P2("pagination.next"))));
}
function Ut(t3, n2) {
return "string" == typeof t3 ? t3.indexOf("%") > -1 ? n2 / 100 * parseInt(t3, 10) : parseInt(t3, 10) : t3;
}
function Wt(t3) {
return t3 ? Math.floor(t3) + "px" : "";
}
function Bt(t3) {
var n2 = t3.tableRef.cloneNode(true);
return n2.style.position = "absolute", n2.style.width = "100%", n2.style.zIndex = "-2147483640", n2.style.visibility = "hidden", w("div", { ref: function(t4) {
t4 && t4.appendChild(n2);
} });
}
function qt(t3) {
if (!t3) return "";
var n2 = t3.split(" ");
return 1 === n2.length && /([a-z][A-Z])+/g.test(t3) ? t3 : n2.map(function(t4, n3) {
return 0 == n3 ? t4.toLowerCase() : t4.charAt(0).toUpperCase() + t4.slice(1).toLowerCase();
}).join("");
}
var zt;
var Vt = new (/* @__PURE__ */ function() {
function t3() {
}
var n2 = t3.prototype;
return n2.format = function(t4, n3) {
return "[Grid.js] [" + n3.toUpperCase() + "]: " + t4;
}, n2.error = function(t4, n3) {
void 0 === n3 && (n3 = false);
var e2 = this.format(t4, "error");
if (n3) throw Error(e2);
console.error(e2);
}, n2.warn = function(t4) {
console.warn(this.format(t4, "warn"));
}, n2.info = function(t4) {
console.info(this.format(t4, "info"));
}, t3;
}())();
!function(t3) {
t3[t3.Header = 0] = "Header", t3[t3.Footer = 1] = "Footer", t3[t3.Cell = 2] = "Cell";
}(zt || (zt = {}));
var $t = /* @__PURE__ */ function() {
function t3() {
this.plugins = void 0, this.plugins = [];
}
var n2 = t3.prototype;
return n2.get = function(t4) {
return this.plugins.find(function(n3) {
return n3.id === t4;
});
}, n2.add = function(t4) {
return t4.id ? this.get(t4.id) ? (Vt.error("Duplicate plugin ID: " + t4.id), this) : (this.plugins.push(t4), this) : (Vt.error("Plugin ID cannot be empty"), this);
}, n2.remove = function(t4) {
var n3 = this.get(t4);
return n3 && this.plugins.splice(this.plugins.indexOf(n3), 1), this;
}, n2.list = function(t4) {
var n3;
return n3 = null != t4 || null != t4 ? this.plugins.filter(function(n4) {
return n4.position === t4;
}) : this.plugins, n3.sort(function(t5, n4) {
return t5.order && n4.order ? t5.order - n4.order : 1;
});
}, t3;
}();
function Gt(t3) {
var n2 = this, r2 = It();
if (t3.pluginId) {
var o2 = r2.plugin.get(t3.pluginId);
return o2 ? w(S, {}, w(o2.component, e({ plugin: o2 }, t3.props))) : null;
}
return void 0 !== t3.position ? w(S, {}, r2.plugin.list(t3.position).map(function(t4) {
return w(t4.component, e({ plugin: t4 }, n2.props.props));
})) : null;
}
var Kt = /* @__PURE__ */ function(t3) {
function o2() {
var n2;
return (n2 = t3.call(this) || this)._columns = void 0, n2._columns = [], n2;
}
r(o2, t3);
var i2 = o2.prototype;
return i2.adjustWidth = function(t4, n2, r2) {
var i3 = t4.container, u2 = t4.autoWidth;
if (!i3) return this;
var a2 = i3.clientWidth, l2 = {};
n2.current && u2 && (q(w(Bt, { tableRef: n2.current }), r2.current), l2 = function(t5) {
var n3 = t5.querySelector("table");
if (!n3) return {};
var r3 = n3.className, o3 = n3.style.cssText;
n3.className = r3 + " " + et("shadowTable"), n3.style.tableLayout = "auto", n3.style.width = "auto", n3.style.padding = "0", n3.style.margin = "0", n3.style.border = "none", n3.style.outline = "none";
var i4 = Array.from(n3.parentNode.querySelectorAll("thead th")).reduce(function(t6, n4) {
var r4;
return n4.style.width = n4.clientWidth + "px", e(((r4 = {})[n4.getAttribute("data-column-id")] = { minWidth: n4.clientWidth }, r4), t6);
}, {});
return n3.className = r3, n3.style.cssText = o3, n3.style.tableLayout = "auto", Array.from(n3.parentNode.querySelectorAll("thead th")).reduce(function(t6, n4) {
return t6[n4.getAttribute("data-column-id")].width = n4.clientWidth, t6;
}, i4);
}(r2.current));
for (var c2, f2 = s(o2.tabularFormat(this.columns).reduce(function(t5, n3) {
return t5.concat(n3);
}, [])); !(c2 = f2()).done; ) {
var p2 = c2.value;
p2.columns && p2.columns.length > 0 || (!p2.width && u2 ? p2.id in l2 && (p2.width = Wt(l2[p2.id].width), p2.minWidth = Wt(l2[p2.id].minWidth)) : p2.width = Wt(Ut(p2.width, a2)));
}
return n2.current && u2 && q(null, r2.current), this;
}, i2.setSort = function(t4, n2) {
for (var r2, o3 = s(n2 || this.columns || []); !(r2 = o3()).done; ) {
var i3 = r2.value;
i3.columns && i3.columns.length > 0 ? i3.sort = void 0 : void 0 === i3.sort && t4 ? i3.sort = {} : i3.sort ? "object" == typeof i3.sort && (i3.sort = e({}, i3.sort)) : i3.sort = void 0, i3.columns && this.setSort(t4, i3.columns);
}
}, i2.setResizable = function(t4, n2) {
for (var e2, r2 = s(n2 || this.columns || []); !(e2 = r2()).done; ) {
var o3 = e2.value;
void 0 === o3.resizable && (o3.resizable = t4), o3.columns && this.setResizable(t4, o3.columns);
}
}, i2.setID = function(t4) {
for (var n2, e2 = s(t4 || this.columns || []); !(n2 = e2()).done; ) {
var r2 = n2.value;
r2.id || "string" != typeof r2.name || (r2.id = qt(r2.name)), r2.id || Vt.error('Could not find a valid ID for one of the columns. Make sure a valid "id" is set for all columns.'), r2.columns && this.setID(r2.columns);
}
}, i2.populatePlugins = function(t4, n2) {
for (var r2, o3 = s(n2); !(r2 = o3()).done; ) {
var i3 = r2.value;
void 0 !== i3.plugin && t4.add(e({ id: i3.id }, i3.plugin, { position: zt.Cell }));
}
}, o2.fromColumns = function(t4) {
for (var n2, e2 = new o2(), r2 = s(t4); !(n2 = r2()).done; ) {
var i3 = n2.value;
if ("string" == typeof i3 || p(i3)) e2.columns.push({ name: i3 });
else if ("object" == typeof i3) {
var u2 = i3;
u2.columns && (u2.columns = o2.fromColumns(u2.columns).columns), "object" == typeof u2.plugin && void 0 === u2.data && (u2.data = null), e2.columns.push(i3);
}
}
return e2;
}, o2.createFromConfig = function(t4) {
var n2 = new o2();
return t4.from ? n2.columns = o2.fromHTMLTable(t4.from).columns : t4.columns ? n2.columns = o2.fromColumns(t4.columns).columns : !t4.data || "object" != typeof t4.data[0] || t4.data[0] instanceof Array || (n2.columns = Object.keys(t4.data[0]).map(function(t5) {
return { name: t5 };
})), n2.columns.length ? (n2.setID(), n2.setSort(t4.sort), n2.setResizable(t4.resizable), n2.populatePlugins(t4.plugin, n2.columns), n2) : null;
}, o2.fromHTMLTable = function(t4) {
for (var n2, e2 = new o2(), r2 = s(t4.querySelector("thead").querySelectorAll("th")); !(n2 = r2()).done; ) {
var i3 = n2.value;
e2.columns.push({ name: i3.innerHTML, width: i3.width });
}
return e2;
}, o2.tabularFormat = function(t4) {
var n2 = [], e2 = t4 || [], r2 = [];
if (e2 && e2.length) {
n2.push(e2);
for (var o3, i3 = s(e2); !(o3 = i3()).done; ) {
var u2 = o3.value;
u2.columns && u2.columns.length && (r2 = r2.concat(u2.columns));
}
r2.length && (n2 = n2.concat(this.tabularFormat(r2)));
}
return n2;
}, o2.leafColumns = function(t4) {
var n2 = [], e2 = t4 || [];
if (e2 && e2.length) for (var r2, o3 = s(e2); !(r2 = o3()).done; ) {
var i3 = r2.value;
i3.columns && 0 !== i3.columns.length || n2.push(i3), i3.columns && (n2 = n2.concat(this.leafColumns(i3.columns)));
}
return n2;
}, o2.maximumDepth = function(t4) {
return this.tabularFormat([t4]).length - 1;
}, n(o2, [{ key: "columns", get: function() {
return this._columns;
}, set: function(t4) {
this._columns = t4;
} }, { key: "visibleColumns", get: function() {
return this._columns.filter(function(t4) {
return !t4.hidden;
});
} }]), o2;
}(V);
var Xt = function() {
};
var Zt = /* @__PURE__ */ function(t3) {
function n2(n3) {
var e3;
return (e3 = t3.call(this) || this).data = void 0, e3.set(n3), e3;
}
r(n2, t3);
var e2 = n2.prototype;
return e2.get = function() {
try {
return Promise.resolve(this.data()).then(function(t4) {
return { data: t4, total: t4.length };
});
} catch (t4) {
return Promise.reject(t4);
}
}, e2.set = function(t4) {
return t4 instanceof Array ? this.data = function() {
return t4;
} : t4 instanceof Function && (this.data = t4), this;
}, n2;
}(Xt);
var Jt = /* @__PURE__ */ function(t3) {
function n2(n3) {
var e2;
return (e2 = t3.call(this) || this).options = void 0, e2.options = n3, e2;
}
r(n2, t3);
var o2 = n2.prototype;
return o2.handler = function(t4) {
return "function" == typeof this.options.handle ? this.options.handle(t4) : t4.ok ? t4.json() : (Vt.error("Could not fetch data: " + t4.status + " - " + t4.statusText, true), null);
}, o2.get = function(t4) {
var n3 = e({}, this.options, t4);
return "function" == typeof n3.data ? n3.data(n3) : fetch(n3.url, n3).then(this.handler.bind(this)).then(function(t5) {
return { data: n3.then(t5), total: "function" == typeof n3.total ? n3.total(t5) : void 0 };
});
}, n2;
}(Xt);
var Qt = /* @__PURE__ */ function() {
function t3() {
}
return t3.createFromConfig = function(t4) {
var n2 = null;
return t4.data && (n2 = new Zt(t4.data)), t4.from && (n2 = new Zt(this.tableElementToArray(t4.from)), t4.from.style.display = "none"), t4.server && (n2 = new Jt(t4.server)), n2 || Vt.error("Could not determine the storage type", true), n2;
}, t3.tableElementToArray = function(t4) {
for (var n2, e2, r2 = [], o2 = s(t4.querySelector("tbody").querySelectorAll("tr")); !(n2 = o2()).done; ) {
for (var i2, u2 = [], a2 = s(n2.value.querySelectorAll("td")); !(i2 = a2()).done; ) {
var l2 = i2.value;
1 === l2.childNodes.length && l2.childNodes[0].nodeType === Node.TEXT_NODE ? u2.push((e2 = l2.innerHTML, new DOMParser().parseFromString(e2, "text/html").documentElement.textContent)) : u2.push(G(l2.innerHTML));
}
r2.push(u2);
}
return r2;
}, t3;
}();
var Yt = "undefined" != typeof Symbol ? Symbol.iterator || (Symbol.iterator = Symbol("Symbol.iterator")) : "@@iterator";
function tn(t3, n2, e2) {
if (!t3.s) {
if (e2 instanceof nn) {
if (!e2.s) return void (e2.o = tn.bind(null, t3, n2));
1 & n2 && (n2 = e2.s), e2 = e2.v;
}
if (e2 && e2.then) return void e2.then(tn.bind(null, t3, n2), tn.bind(null, t3, 2));
t3.s = n2, t3.v = e2;
var r2 = t3.o;
r2 && r2(t3);
}
}
var nn = /* @__PURE__ */ function() {
function t3() {
}
return t3.prototype.then = function(n2, e2) {
var r2 = new t3(), o2 = this.s;
if (o2) {
var i2 = 1 & o2 ? n2 : e2;
if (i2) {
try {
tn(r2, 1, i2(this.v));
} catch (t4) {
tn(r2, 2, t4);
}
return r2;
}
return this;
}
return this.o = function(t4) {
try {
var o3 = t4.v;
1 & t4.s ? tn(r2, 1, n2 ? n2(o3) : o3) : e2 ? tn(r2, 1, e2(o3)) : tn(r2, 2, o3);
} catch (t5) {
tn(r2, 2, t5);
}
}, r2;
}, t3;
}();
function en(t3) {
return t3 instanceof nn && 1 & t3.s;
}
var rn = /* @__PURE__ */ function(t3) {
function e2(n2) {
var e3;
return (e3 = t3.call(this) || this)._steps = /* @__PURE__ */ new Map(), e3.cache = /* @__PURE__ */ new Map(), e3.lastProcessorIndexUpdated = -1, n2 && n2.forEach(function(t4) {
return e3.register(t4);
}), e3;
}
r(e2, t3);
var o2 = e2.prototype;
return o2.clearCache = function() {
this.cache = /* @__PURE__ */ new Map(), this.lastProcessorIndexUpdated = -1;
}, o2.register = function(t4, n2) {
if (void 0 === n2 && (n2 = null), !t4) throw Error("Processor is not defined");
if (null === t4.type) throw Error("Processor type is not defined");
if (this.findProcessorIndexByID(t4.id) > -1) throw Error("Processor ID " + t4.id + " is already defined");
return t4.on("propsUpdated", this.processorPropsUpdated.bind(this)), this.addProcessorByPriority(t4, n2), this.afterRegistered(t4), t4;
}, o2.tryRegister = function(t4, n2) {
void 0 === n2 && (n2 = null);
try {
return this.register(t4, n2);
} catch (t5) {
}
}, o2.unregister = function(t4) {
if (t4 && -1 !== this.findProcessorIndexByID(t4.id)) {
var n2 = this._steps.get(t4.type);
n2 && n2.length && (this._steps.set(t4.type, n2.filter(function(n3) {
return n3 != t4;
})), this.emit("updated", t4));
}
}, o2.addProcessorByPriority = function(t4, n2) {
var e3 = this._steps.get(t4.type);
if (!e3) {
var r2 = [];
this._steps.set(t4.type, r2), e3 = r2;
}
if (null === n2 || n2 < 0) e3.push(t4);
else if (e3[n2]) {
var o3 = e3.slice(0, n2 - 1), i2 = e3.slice(n2 + 1);
this._steps.set(t4.type, o3.concat(t4).concat(i2));
} else e3[n2] = t4;
}, o2.getStepsByType = function(t4) {
return this.steps.filter(function(n2) {
return n2.type === t4;
});
}, o2.getSortedProcessorTypes = function() {
return Object.keys(K).filter(function(t4) {
return !isNaN(Number(t4));
}).map(function(t4) {
return Number(t4);
});
}, o2.process = function(t4) {
try {
var n2 = function(t5) {
return e3.lastProcessorIndexUpdated = o3.length, e3.emit("afterProcess", i2), i2;
}, e3 = this, r2 = e3.lastProcessorIndexUpdated, o3 = e3.steps, i2 = t4, u2 = function(t5, n3) {
try {
var u3 = function(t6, n4, e4) {
if ("function" == typeof t6[Yt]) {
var r3, o4, i3, u4 = t6[Yt]();
if (function t7(e5) {
try {
for (; !(r3 = u4.next()).done; ) if ((e5 = n4(r3.value)) && e5.then) {
if (!en(e5)) return void e5.then(t7, i3 || (i3 = tn.bind(null, o4 = new nn(), 2)));
e5 = e5.v;
}
o4 ? tn(o4, 1, e5) : o4 = e5;
} catch (t8) {
tn(o4 || (o4 = new nn()), 2, t8);
}
}(), u4.return) {
var s2 = function(t7) {
try {
r3.done || u4.return();
} catch (t8) {
}
return t7;
};
if (o4 && o4.then) return o4.then(s2, function(t7) {
throw s2(t7);
});
s2();
}
return o4;
}
if (!("length" in t6)) throw new TypeError("Object is not iterable");
for (var a2 = [], l2 = 0; l2 < t6.length; l2++) a2.push(t6[l2]);
return function(t7, n5, e5) {
var r4, o5, i4 = -1;
return function e6(u5) {
try {
for (; ++i4 < t7.length; ) if ((u5 = n5(i4)) && u5.then) {
if (!en(u5)) return void u5.then(e6, o5 || (o5 = tn.bind(null, r4 = new nn(), 2)));
u5 = u5.v;
}
r4 ? tn(r4, 1, u5) : r4 = u5;
} catch (t8) {
tn(r4 || (r4 = new nn()), 2, t8);
}
}(), r4;
}(a2, function(t7) {
return n4(a2[t7]);
});
}(o3, function(t6) {
var n4 = e3.findProcessorIndexByID(t6.id), o4 = function() {
if (n4 >= r2) return Promise.resolve(t6.process(i2)).then(function(n5) {
e3.cache.set(t6.id, i2 = n5);
});
i2 = e3.cache.get(t6.id);
}();
if (o4 && o4.then) return o4.then(function() {
});
});
} catch (t6) {
return n3(t6);
}
return u3 && u3.then ? u3.then(void 0, n3) : u3;
}(0, function(t5) {
throw Vt.error(t5), e3.emit("error", i2), t5;
});
return Promise.resolve(u2 && u2.then ? u2.then(n2) : n2());
} catch (t5) {
return Promise.reject(t5);
}
}, o2.findProcessorIndexByID = function(t4) {
return this.steps.findIndex(function(n2) {
return n2.id == t4;
});
}, o2.setLastProcessorIndex = function(t4) {
var n2 = this.findProcessorIndexByID(t4.id);
this.lastProcessorIndexUpdated > n2 && (this.lastProcessorIndexUpdated = n2);
}, o2.processorPropsUpdated = function(t4) {
this.setLastProcessorIndex(t4), this.emit("propsUpdated"), this.emit("updated", t4);
}, o2.afterRegistered = function(t4) {
this.setLastProcessorIndex(t4), this.emit("afterRegister"), this.emit("updated", t4);
}, n(e2, [{ key: "steps", get: function() {
for (var t4, n2 = [], e3 = s(this.getSortedProcessorTypes()); !(t4 = e3()).done; ) {
var r2 = this._steps.get(t4.value);
r2 && r2.length && (n2 = n2.concat(r2));
}
return n2.filter(function(t5) {
return t5;
});
} }]), e2;
}(Q);
var on = /* @__PURE__ */ function(t3) {
function e2() {
return t3.apply(this, arguments) || this;
}
return r(e2, t3), e2.prototype._process = function(t4) {
try {
return Promise.resolve(this.props.storage.get(t4));
} catch (t5) {
return Promise.reject(t5);
}
}, n(e2, [{ key: "type", get: function() {
return K.Extractor;
} }]), e2;
}(tt);
var un = /* @__PURE__ */ function(t3) {
function e2() {
return t3.apply(this, arguments) || this;
}
return r(e2, t3), e2.prototype._process = function(t4) {
var n2 = J.fromArray(t4.data);
return n2.length = t4.total, n2;
}, n(e2, [{ key: "type", get: function() {
return K.Transformer;
} }]), e2;
}(tt);
var sn = /* @__PURE__ */ function(t3) {
function o2() {
return t3.apply(this, arguments) || this;
}
return r(o2, t3), o2.prototype._process = function() {
return Object.entries(this.props.serverStorageOptions).filter(function(t4) {
return "function" != typeof t4[1];
}).reduce(function(t4, n2) {
var r2;
return e({}, t4, ((r2 = {})[n2[0]] = n2[1], r2));
}, {});
}, n(o2, [{ key: "type", get: function() {
return K.Initiator;
} }]), o2;
}(tt);
var an = /* @__PURE__ */ function(t3) {
function e2() {
return t3.apply(this, arguments) || this;
}
r(e2, t3);
var o2 = e2.prototype;
return o2.castData = function(t4) {
if (!t4 || !t4.length) return [];
if (!this.props.header || !this.props.header.columns) return t4;
var n2 = Kt.leafColumns(this.props.header.columns);
return t4[0] instanceof Array ? t4.map(function(t5) {
var e3 = 0;
return n2.map(function(n3, r2) {
return void 0 !== n3.data ? (e3++, "function" == typeof n3.data ? n3.data(t5) : n3.data) : t5[r2 - e3];
});
}) : "object" != typeof t4[0] || t4[0] instanceof Array ? [] : t4.map(function(t5) {
return n2.map(function(n3, e3) {
return void 0 !== n3.data ? "function" == typeof n3.data ? n3.data(t5) : n3.data : n3.id ? t5[n3.id] : (Vt.error("Could not find the correct cell for column at position " + e3 + ".\n Make sure either 'id' or 'selector' is defined for all columns."), null);
});
});
}, o2._process = function(t4) {
return { data: this.castData(t4.data), total: t4.total };
}, n(e2, [{ key: "type", get: function() {
return K.Transformer;
} }]), e2;
}(tt);
var ln = /* @__PURE__ */ function() {
function t3() {
}
return t3.createFromConfig = function(t4) {
var n2 = new rn();
return t4.storage instanceof Jt && n2.register(new sn({ serverStorageOptions: t4.server })), n2.register(new on({ storage: t4.storage })), n2.register(new an({ header: t4.header })), n2.register(new un()), n2;
}, t3;
}();
var cn = function(t3) {
var n2 = this;
this.state = void 0, this.listeners = [], this.isDispatching = false, this.getState = function() {
return n2.state;
}, this.getListeners = function() {
return n2.listeners;
}, this.dispatch = function(t4) {
if ("function" != typeof t4) throw new Error("Reducer is not a function");
if (n2.isDispatching) throw new Error("Reducers may not dispatch actions");
n2.isDispatching = true;
var e2 = n2.state;
try {
n2.state = t4(n2.state);
} finally {
n2.isDispatching = false;
}
for (var r2, o2 = s(n2.listeners); !(r2 = o2()).done; ) (0, r2.value)(n2.state, e2);
return n2.state;
}, this.subscribe = function(t4) {
if ("function" != typeof t4) throw new Error("Listener is not a function");
return n2.listeners = [].concat(n2.listeners, [t4]), function() {
return n2.listeners = n2.listeners.filter(function(n3) {
return n3 !== t4;
});
};
}, this.state = t3;
};
var fn = function(t3, n2) {
var e2 = { __c: n2 = "__cC" + _++, __: null, Consumer: function(t4, n3) {
return t4.children(n3);
}, Provider: function(t4) {
var e3, r2;
return this.getChildContext || (e3 = [], (r2 = {})[n2] = this, this.getChildContext = function() {
return r2;
}, this.shouldComponentUpdate = function(t5) {
this.props.value !== t5.value && e3.some(E);
}, this.sub = function(t5) {
e3.push(t5);
var n3 = t5.componentWillUnmount;
t5.componentWillUnmount = function() {
e3.splice(e3.indexOf(t5), 1), n3 && n3.call(t5);
};
}), t4.children;
} };
return e2.Provider.__ = e2.Consumer.contextType = e2;
}();
var pn = /* @__PURE__ */ function() {
function t3() {
Object.assign(this, t3.defaultConfig());
}
var n2 = t3.prototype;
return n2.assign = function(t4) {
return Object.assign(this, t4);
}, n2.update = function(n3) {
return n3 ? (this.assign(t3.fromPartialConfig(e({}, this, n3))), this) : this;
}, t3.defaultConfig = function() {
return { store: new cn({ status: a.Init, header: void 0, data: null }), plugin: new $t(), tableRef: { current: null }, width: "100%", height: "auto", processingThrottleMs: 100, autoWidth: true, style: {}, className: {} };
}, t3.fromPartialConfig = function(n3) {
var e2 = new t3().assign(n3);
return "boolean" == typeof n3.sort && n3.sort && e2.assign({ sort: { multiColumn: true } }), e2.assign({ header: Kt.createFromConfig(e2) }), e2.assign({ storage: Qt.createFromConfig(e2) }), e2.assign({ pipeline: ln.createFromConfig(e2) }), e2.assign({ translator: new Lt(e2.language) }), e2.plugin = new $t(), e2.search && e2.plugin.add({ id: "search", position: zt.Header, component: Dt }), e2.pagination && e2.plugin.add({ id: "pagination", position: zt.Footer, component: Rt }), e2.plugins && e2.plugins.forEach(function(t4) {
return e2.plugin.add(t4);
}), e2;
}, t3;
}();
function dn(t3) {
var n2, r2 = It();
return w("td", e({ role: t3.role, colSpan: t3.colSpan, "data-column-id": t3.column && t3.column.id, className: rt(et("td"), t3.className, r2.className.td), style: e({}, t3.style, r2.style.td), onClick: function(n3) {
t3.messageCell || r2.eventEmitter.emit("cellClick", n3, t3.cell, t3.column, t3.row);
} }, (n2 = t3.column) ? "function" == typeof n2.attributes ? n2.attributes(t3.cell.data, t3.row, t3.column) : n2.attributes : {}), t3.column && "function" == typeof t3.column.formatter ? t3.column.formatter(t3.cell.data, t3.row, t3.column) : t3.column && t3.column.plugin ? w(Gt, { pluginId: t3.column.id, props: { column: t3.column, cell: t3.cell, row: t3.row } }) : t3.cell.data);
}
function hn(t3) {
var n2 = It(), e2 = jt(function(t4) {
return t4.header;
});
return w("tr", { className: rt(et("tr"), n2.className.tr), onClick: function(e3) {
t3.messageRow || n2.eventEmitter.emit("rowClick", e3, t3.row);
} }, t3.children ? t3.children : t3.row.cells.map(function(n3, r2) {
var o2 = function(t4) {
if (e2) {
var n4 = Kt.leafColumns(e2.columns);
if (n4) return n4[t4];
}
return null;
}(r2);
return o2 && o2.hidden ? null : w(dn, { key: n3.id, cell: n3, row: t3.row, column: o2 });
}));
}
function _n(t3) {
return w(hn, { messageRow: true }, w(dn, { role: "alert", colSpan: t3.colSpan, messageCell: true, cell: new X(t3.message), className: rt(et("message"), t3.className ? t3.className : null) }));
}
function mn() {
var t3 = It(), n2 = jt(function(t4) {
return t4.data;
}), e2 = jt(function(t4) {
return t4.status;
}), r2 = jt(function(t4) {
return t4.header;
}), o2 = At(), i2 = function() {
return r2 ? r2.visibleColumns.length : 0;
};
return w("tbody", { className: rt(et("tbody"), t3.className.tbody) }, n2 && n2.rows.map(function(t4) {
return w(hn, { key: t4.id, row: t4 });
}), e2 === a.Loading && (!n2 || 0 === n2.length) && w(_n, { message: o2("loading"), colSpan: i2(), className: rt(et("loading"), t3.className.loading) }), e2 === a.Rendered && n2 && 0 === n2.length && w(_n, { message: o2("noRecordsFound"), colSpan: i2(), className: rt(et("notfound"), t3.className.notfound) }), e2 === a.Error && w(_n, { message: o2("error"), colSpan: i2(), className: rt(et("error"), t3.className.error) }));
}
var vn = /* @__PURE__ */ function(t3) {
function e2() {
return t3.apply(this, arguments) || this;
}
r(e2, t3);
var o2 = e2.prototype;
return o2.validateProps = function() {
for (var t4, n2 = s(this.props.columns); !(t4 = n2()).done; ) {
var e3 = t4.value;
void 0 === e3.direction && (e3.direction = 1), 1 !== e3.direction && -1 !== e3.direction && Vt.error("Invalid sort direction " + e3.direction);
}
}, o2.compare = function(t4, n2) {
return t4 > n2 ? 1 : t4 < n2 ? -1 : 0;
}, o2.compareWrapper = function(t4, n2) {
for (var e3, r2 = 0, o3 = s(this.props.columns); !(e3 = o3()).done; ) {
var i2 = e3.value;
if (0 !== r2) break;
var u2 = t4.cells[i2.index].data, a2 = n2.cells[i2.index].data;
r2 |= "function" == typeof i2.compare ? i2.compare(u2, a2) * i2.direction : this.compare(u2, a2) * i2.direction;
}
return r2;
}, o2._process = function(t4) {
var n2 = [].concat(t4.rows);
n2.sort(this.compareWrapper.bind(this));
var e3 = new J(n2);
return e3.length = t4.length, e3;
}, n(e2, [{ key: "type", get: function() {
return K.Sort;
} }]), e2;
}(tt);
var yn = function(t3, n2, r2, o2) {
return function(i2) {
var u2, s2 = null != (u2 = i2.sort) && u2.columns ? i2.sort.columns.map(function(t4) {
return e({}, t4);
}) : [], a2 = s2.length, l2 = s2.find(function(n3) {
return n3.index === t3;
}), c2 = false, f2 = false, p2 = false, d2 = false;
if (void 0 !== l2 ? r2 ? -1 === l2.direction ? p2 = true : d2 = true : 1 === a2 ? d2 = true : a2 > 1 && (f2 = true, c2 = true) : 0 === a2 ? c2 = true : a2 > 0 && !r2 ? (c2 = true, f2 = true) : a2 > 0 && r2 && (c2 = true), f2 && (s2 = []), c2) s2.push({ index: t3, direction: n2, compare: o2 });
else if (d2) {
var h6 = s2.indexOf(l2);
s2[h6].direction = n2;
} else if (p2) {
var _2 = s2.indexOf(l2);
s2.splice(_2, 1);
}
return e({}, i2, { sort: { columns: s2 } });
};
};
var gn = function(t3, n2, r2) {
return function(o2) {
var i2 = (o2.sort ? [].concat(o2.sort.columns) : []).find(function(n3) {
return n3.index === t3;
});
return e({}, o2, i2 ? yn(t3, 1 === i2.direction ? -1 : 1, n2, r2)(o2) : yn(t3, 1, n2, r2)(o2));
};
};
var bn = /* @__PURE__ */ function(t3) {
function o2() {
return t3.apply(this, arguments) || this;
}
return r(o2, t3), o2.prototype._process = function(t4) {
var n2 = {};
return this.props.url && (n2.url = this.props.url(t4.url, this.props.columns)), this.props.body && (n2.body = this.props.body(t4.body, this.props.columns)), e({}, t4, n2);
}, n(o2, [{ key: "type", get: function() {
return K.ServerSort;
} }]), o2;
}(tt);
function wn(t3) {
var n2 = It(), r2 = Ht().dispatch, o2 = At(), i2 = yt(0), u2 = i2[0], s2 = i2[1], a2 = n2.sort, l2 = jt(function(t4) {
return t4.sort;
}), c2 = "object" == typeof (null == a2 ? void 0 : a2.server) ? K.ServerSort : K.Sort, f2 = function() {
var t4 = n2.pipeline.getStepsByType(c2);
if (t4.length) return t4[0];
};
return gt(function() {
var t4 = f2() || (c2 === K.ServerSort ? new bn(e({ columns: l2 ? l2.columns : [] }, a2.server)) : new vn({ columns: l2 ? l2.columns : [] }));
return n2.pipeline.tryRegister(t4), function() {
return n2.pipeline.unregister(t4);
};
}, [n2]), gt(function() {
if (l2) {
var n3, e2 = l2.columns.find(function(n4) {
return n4.index === t3.index;
});
e2 ? (0 === u2 && (e2.direction = null != (n3 = t3.direction) ? n3 : 1), s2(e2.direction)) : s2(0);
}
}, [l2]), gt(function() {
var t4 = f2();
t4 && l2 && t4.setProps({ columns: l2.columns });
}, [l2]), w("button", { tabIndex: -1, "aria-label": o2("sort.sort" + (1 === u2 ? "Desc" : "Asc")), title: o2("sort.sort" + (1 === u2 ? "Desc" : "Asc")), className: rt(et("sort"), et("sort", /* @__PURE__ */ function(t4) {
return 1 === t4 ? "asc" : -1 === t4 ? "desc" : "neutral";
}(u2)), n2.className.sort), onClick: function(n3) {
n3.preventDefault(), n3.stopPropagation(), r2(gn(t3.index, true === n3.shiftKey && a2.multiColumn, t3.compare));
} });
}
var xn = function(t3, n2) {
var e2;
void 0 === n2 && (n2 = 100);
var r2 = Date.now(), o2 = function() {
r2 = Date.now(), t3.apply(void 0, [].slice.call(arguments));
};
return function() {
var t4 = [].slice.call(arguments), i2 = Date.now(), u2 = i2 - r2;
u2 >= n2 ? o2.apply(void 0, t4) : (e2 && clearTimeout(e2), e2 = setTimeout(function() {
o2.apply(void 0, t4), e2 = null;
}, n2 - u2));
};
};
function kn(t3) {
var n2, e2 = function(t4) {
return t4 instanceof MouseEvent ? Math.floor(t4.pageX) : Math.floor(t4.changedTouches[0].pageX);
}, r2 = function(r3) {
r3.stopPropagation();
var u2 = parseInt(t3.thRef.current.style.width, 10) - e2(r3);
n2 = xn(function(t4) {
return o2(t4, u2);
}, 10), document.addEventListener("mouseup", i2), document.addEventListener("touchend", i2), document.addEventListener("mousemove", n2), document.addEventListener("touchmove", n2);
}, o2 = function(n3, r3) {
n3.stopPropagation();
var o3 = t3.thRef.current;
r3 + e2(n3) >= parseInt(o3.style.minWidth, 10) && (o3.style.width = r3 + e2(n3) + "px");
}, i2 = function t4(e3) {
e3.stopPropagation(), document.removeEventListener("mouseup", t4), document.removeEventListener("mousemove", n2), document.removeEventListener("touchmove", n2), document.removeEventListener("touchend", t4);
};
return w("div", { className: rt(et("th"), et("resizable")), onMouseDown: r2, onTouchStart: r2, onClick: function(t4) {
return t4.stopPropagation();
} });
}
function Sn(t3) {
var n2 = It(), r2 = bt(null), o2 = yt({}), i2 = o2[0], u2 = o2[1], s2 = Ht().dispatch;
gt(function() {
if (n2.fixedHeader && r2.current) {
var t4 = r2.current.offsetTop;
"number" == typeof t4 && u2({ top: t4 });
}
}, [r2]);
var a2, l2 = function() {
return null != t3.column.sort;
}, c2 = function(e2) {
e2.stopPropagation(), l2() && s2(gn(t3.index, true === e2.shiftKey && n2.sort.multiColumn, t3.column.sort.compare));
};
return w("th", e({ ref: r2, "data-column-id": t3.column && t3.column.id, className: rt(et("th"), l2() ? et("th", "sort") : null, n2.fixedHeader ? et("th", "fixed") : null, n2.className.th), onClick: c2, style: e({}, n2.style.th, { minWidth: t3.column.minWidth, width: t3.column.width }, i2, t3.style), onKeyDown: function(t4) {
l2() && 13 === t4.which && c2(t4);
}, rowSpan: t3.rowSpan > 1 ? t3.rowSpan : void 0, colSpan: t3.colSpan > 1 ? t3.colSpan : void 0 }, (a2 = t3.column) ? "function" == typeof a2.attributes ? a2.attributes(null, null, t3.column) : a2.attributes : {}, l2() ? { tabIndex: 0 } : {}), w("div", { className: et("th", "content") }, void 0 !== t3.column.name ? t3.column.name : void 0 !== t3.column.plugin ? w(Gt, { pluginId: t3.column.plugin.id, props: { column: t3.column } }) : null), l2() && w(wn, e({ index: t3.index }, t3.column.sort)), t3.column.resizable && t3.index < n2.header.visibleColumns.length - 1 && w(kn, { column: t3.column, thRef: r2 }));
}
function Nn() {
var t3, n2 = It(), e2 = jt(function(t4) {
return t4.header;
});
return e2 ? w("thead", { key: e2.id, className: rt(et("thead"), n2.className.thead) }, (t3 = Kt.tabularFormat(e2.columns)).map(function(n3, r2) {
return function(t4, n4, r3) {
var o2 = Kt.leafColumns(e2.columns);
return w(hn, null, t4.map(function(t5) {
return t5.hidden ? null : function(t6, n5, e3, r4) {
var o3 = function(t7, n6, e4) {
var r5 = Kt.maximumDepth(t7), o4 = e4 - n6;
return { rowSpan: Math.floor(o4 - r5 - r5 / o4), colSpan: t7.columns && t7.columns.length || 1 };
}(t6, n5, r4);
return w(Sn, { column: t6, index: e3, colSpan: o3.colSpan, rowSpan: o3.rowSpan });
}(t5, n4, o2.indexOf(t5), r3);
}));
}(n3, r2, t3.length);
})) : null;
}
var Pn = function(t3) {
return function(n2) {
return e({}, n2, { header: t3 });
};
};
function Cn() {
var t3 = It(), n2 = bt(null), r2 = Ht().dispatch;
return gt(function() {
n2 && r2(/* @__PURE__ */ function(t4) {
return function(n3) {
return e({}, n3, { tableRef: t4 });
};
}(n2));
}, [n2]), w("table", { ref: n2, role: "grid", className: rt(et("table"), t3.className.table), style: e({}, t3.style.table, { height: t3.height }) }, w(Nn, null), w(mn, null));
}
function En() {
var t3 = yt(true), n2 = t3[0], r2 = t3[1], o2 = bt(null), i2 = It();
return gt(function() {
0 === o2.current.children.length && r2(false);
}, [o2]), n2 ? w("div", { ref: o2, className: rt(et("head"), i2.className.header), style: e({}, i2.style.header) }, w(Gt, { position: zt.Header })) : null;
}
function In() {
var t3 = bt(null), n2 = yt(true), r2 = n2[0], o2 = n2[1], i2 = It();
return gt(function() {
0 === t3.current.children.length && o2(false);
}, [t3]), r2 ? w("div", { ref: t3, className: rt(et("footer"), i2.className.footer), style: e({}, i2.style.footer) }, w(Gt, { position: zt.Footer })) : null;
}
function Tn() {
var t3 = It(), n2 = Ht().dispatch, r2 = jt(function(t4) {
return t4.status;
}), o2 = jt(function(t4) {
return t4.data;
}), i2 = jt(function(t4) {
return t4.tableRef;
}), u2 = { current: null }, s2 = xn(function() {
try {
n2(function(t4) {
return e({}, t4, { status: a.Loading });
});
var r3 = function(r4, o3) {
try {
var i3 = Promise.resolve(t3.pipeline.process()).then(function(t4) {
n2(/* @__PURE__ */ function(t5) {
return function(n3) {
return t5 ? e({}, n3, { data: t5, status: a.Loaded }) : n3;
};
}(t4)), setTimeout(function() {
n2(function(t5) {
return t5.status === a.Loaded ? e({}, t5, { status: a.Rendered }) : t5;
});
}, 0);
});
} catch (t4) {
return o3(t4);
}
return i3 && i3.then ? i3.then(void 0, o3) : i3;
}(0, function(t4) {
Vt.error(t4), n2(function(t5) {
return e({}, t5, { data: null, status: a.Error });
});
});
return Promise.resolve(r3 && r3.then ? r3.then(function() {
}) : void 0);
} catch (t4) {
return Promise.reject(t4);
}
}, t3.processingThrottleMs);
return gt(function() {
return n2(Pn(t3.header)), s2(), t3.pipeline.on("updated", s2), function() {
return t3.pipeline.off("updated", s2);
};
}, []), gt(function() {
t3.header && r2 === a.Loaded && null != o2 && o2.length && n2(Pn(t3.header.adjustWidth(t3, i2, u2)));
}, [o2, t3, u2]), w("div", { role: "complementary", className: rt("gridjs", et("container"), r2 === a.Loading ? et("loading") : null, t3.className.container), style: e({}, t3.style.container, { width: t3.width }) }, r2 === a.Loading && w("div", { className: et("loading-bar") }), w(En, null), w("div", { className: et("wrapper"), style: { height: t3.height } }, w(Cn, null)), w(In, null), w("div", { ref: u2, id: "gridjs-temp", className: et("temp") }));
}
var Ln = /* @__PURE__ */ function(t3) {
function n2(n3) {
var e3;
return (e3 = t3.call(this) || this).config = void 0, e3.plugin = void 0, e3.config = new pn().assign({ instance: i(e3), eventEmitter: i(e3) }).update(n3), e3.plugin = e3.config.plugin, e3;
}
r(n2, t3);
var e2 = n2.prototype;
return e2.updateConfig = function(t4) {
return this.config.update(t4), this;
}, e2.createElement = function() {
return w(fn.Provider, { value: this.config, children: w(Tn, {}) });
}, e2.forceRender = function() {
return this.config && this.config.container || Vt.error("Container is empty. Make sure you call render() before forceRender()", true), this.destroy(), q(this.createElement(), this.config.container), this;
}, e2.destroy = function() {
this.config.pipeline.clearCache(), q(null, this.config.container);
}, e2.render = function(t4) {
return t4 || Vt.error("Container element cannot be null", true), t4.childNodes.length > 0 ? (Vt.error("The container element " + t4 + " is not empty. Make sure the container is empty and call render() again"), this) : (this.config.container = t4, q(this.createElement(), t4), this);
}, n2;
}(Q);
// src/gui/statistics.tsx
var import_path = __toESM(require("path"));
var import_vhtml2 = __toESM(require_vhtml());
Chart.register(
BarElement,
BarController,
plugin_legend,
plugin_title,
plugin_tooltip,
plugin_subtitle,
CategoryScale,
LinearScale,
PieController,
ArcElement
);
var StatisticsView = class {
constructor(containerEl, osrCore) {
this.containerEl = containerEl;
this.osrCore = osrCore;
}
render() {
this.containerEl.style.textAlign = "center";
this.containerEl.innerHTML += /* @__PURE__ */ (0, import_vhtml2.default)("select", { id: "sr-chart-period" }, /* @__PURE__ */ (0, import_vhtml2.default)("option", { value: "month", selected: true }, t("MONTH")), /* @__PURE__ */ (0, import_vhtml2.default)("option", { value: "quarter" }, t("QUARTER")), /* @__PURE__ */ (0, import_vhtml2.default)("option", { value: "year" }, t("YEAR")), /* @__PURE__ */ (0, import_vhtml2.default)("option", { value: "lifetime" }, t("LIFETIME")));
const cardStats = this.osrCore.cardStats;
let maxN = cardStats.delayedDays.getMaxValue();
for (let dueOffset = 0; dueOffset <= maxN; dueOffset++) {
cardStats.delayedDays.clearCountIfMissing(dueOffset);
}
const dueDatesFlashcardsCopy = { 0: 0 };
for (const [dueOffset, dueCount] of getTypedObjectEntries(cardStats.delayedDays.dict)) {
if (dueOffset <= 0) {
dueDatesFlashcardsCopy[0] += dueCount;
} else {
dueDatesFlashcardsCopy[dueOffset] = dueCount;
}
}
const scheduledCount = cardStats.youngCount + cardStats.matureCount;
maxN = Math.max(maxN, 1);
this.containerEl.innerHTML += /* @__PURE__ */ (0, import_vhtml2.default)("div", null, /* @__PURE__ */ (0, import_vhtml2.default)("canvas", { id: "forecastChart" }), /* @__PURE__ */ (0, import_vhtml2.default)("span", { id: "forecastChartSummary" }), /* @__PURE__ */ (0, import_vhtml2.default)("br", null), /* @__PURE__ */ (0, import_vhtml2.default)("br", null), /* @__PURE__ */ (0, import_vhtml2.default)("canvas", { id: "intervalsChart" }), /* @__PURE__ */ (0, import_vhtml2.default)("span", { id: "intervalsChartSummary" }), /* @__PURE__ */ (0, import_vhtml2.default)("br", null), /* @__PURE__ */ (0, import_vhtml2.default)("br", null), /* @__PURE__ */ (0, import_vhtml2.default)("canvas", { id: "easesChart" }), /* @__PURE__ */ (0, import_vhtml2.default)("span", { id: "easesChartSummary" }), /* @__PURE__ */ (0, import_vhtml2.default)("br", null), /* @__PURE__ */ (0, import_vhtml2.default)("br", null), /* @__PURE__ */ (0, import_vhtml2.default)("canvas", { id: "cardTypesChart" }), /* @__PURE__ */ (0, import_vhtml2.default)("br", null), /* @__PURE__ */ (0, import_vhtml2.default)("span", { id: "cardTypesChartSummary" }), /* @__PURE__ */ (0, import_vhtml2.default)("br", null), /* @__PURE__ */ (0, import_vhtml2.default)("br", null), /* @__PURE__ */ (0, import_vhtml2.default)("h1", null, "Notes"), /* @__PURE__ */ (0, import_vhtml2.default)("div", { id: "noteStats" }));
this.forecastChart = createStatsChart(
"bar",
"forecastChart",
t("FORECAST"),
t("FORECAST_DESC"),
Object.keys(dueDatesFlashcardsCopy),
Object.values(dueDatesFlashcardsCopy),
t("REVIEWS_PER_DAY", { avg: (scheduledCount / maxN).toFixed(1) }),
t("SCHEDULED"),
t("DAYS"),
t("NUMBER_OF_CARDS")
);
maxN = cardStats.intervals.getMaxValue();
for (let interval = 0; interval <= maxN; interval++) {
cardStats.intervals.clearCountIfMissing(interval);
}
const averageInterval = textInterval(
Math.round(
cardStats.intervals.getTotalOfValueMultiplyCount() / scheduledCount * 10
) / 10 || 0,
false
), longestInterval = textInterval(cardStats.intervals.getMaxValue(), false);
this.intervalsChart = createStatsChart(
"bar",
"intervalsChart",
t("INTERVALS"),
t("INTERVALS_DESC"),
Object.keys(cardStats.intervals.dict),
Object.values(cardStats.intervals.dict),
t("INTERVALS_SUMMARY", { avg: averageInterval, longest: longestInterval }),
t("COUNT"),
t("DAYS"),
t("NUMBER_OF_CARDS")
);
const eases = getKeysPreserveType(cardStats.eases.dict);
for (let ease = Math.min(...eases); ease <= Math.max(...eases); ease++) {
cardStats.eases.clearCountIfMissing(ease);
}
const averageEase = Math.round(cardStats.eases.getTotalOfValueMultiplyCount() / scheduledCount) || 0;
this.easesChart = createStatsChart(
"bar",
"easesChart",
t("EASES"),
"",
Object.keys(cardStats.eases.dict),
Object.values(cardStats.eases.dict),
t("EASES_SUMMARY", { avgEase: averageEase }),
t("COUNT"),
t("EASES"),
t("NUMBER_OF_CARDS")
);
const totalCardsCount = this.osrCore.reviewableDeckTree.getDistinctCardCount(
2 /* All */,
true
);
this.cardTypesChart = createStatsChart(
"pie",
"cardTypesChart",
t("CARD_TYPES"),
t("CARD_TYPES_DESC"),
[
`${t("CARD_TYPE_NEW")} - ${Math.round(cardStats.newCount / totalCardsCount * 100)}%`,
`${t("CARD_TYPE_YOUNG")} - ${Math.round(
cardStats.youngCount / totalCardsCount * 100
)}%`,
`${t("CARD_TYPE_MATURE")} - ${Math.round(
cardStats.matureCount / totalCardsCount * 100
)}%`
],
[cardStats.newCount, cardStats.youngCount, cardStats.matureCount],
t("CARD_TYPES_SUMMARY", { totalCardsCount })
);
const noteEases = mapRecord(
SrsAlgorithm.getInstance().noteStats().dict,
(key, value) => [
import_path.default.parse(key).name,
Math.round(value)
]
);
this.noteStatsGrid = new Ln({
columns: [
{
name: t("NOTE")
},
{
name: t("EASE"),
sort: true,
width: "200px"
}
],
search: true,
autoWidth: false,
data: Object.entries(noteEases).sort((a2, b2) => b2[1] - a2[1]),
pagination: {
limit: 10,
summary: false
},
language: {
search: {
placeholder: t("SEARCH")
},
pagination: {
previous: t("PREVIOUS"),
next: t("NEXT")
}
}
});
this.noteStatsGrid.render(document.getElementById("noteStats"));
}
destroy() {
this.forecastChart.destroy();
this.intervalsChart.destroy();
this.easesChart.destroy();
this.cardTypesChart.destroy();
this.noteStatsGrid.destroy();
}
};
function createStatsChart(type, canvasId, title, subtitle, labels, data, summary, seriesTitle = "", xAxisTitle = "", yAxisTitle = "") {
const style = getComputedStyle(document.body);
const textColor = style.getPropertyValue("--text-normal");
let scales = {}, backgroundColor = ["#2196f3"];
if (type !== "pie") {
scales = {
x: {
title: {
display: true,
text: xAxisTitle,
color: textColor
}
},
y: {
title: {
display: true,
text: yAxisTitle,
color: textColor
}
}
};
} else {
backgroundColor = ["#2196f3", "#4caf50", "green"];
}
const shouldFilter = canvasId === "forecastChart" || canvasId === "intervalsChart";
const statsChart = new Chart(document.getElementById(canvasId), {
type,
data: {
labels: shouldFilter ? labels.slice(0, 31) : labels,
datasets: [
{
label: seriesTitle,
backgroundColor,
data: shouldFilter ? data.slice(0, 31) : data
}
]
},
options: {
scales,
plugins: {
title: {
display: true,
text: title,
font: {
size: 22
},
color: textColor
},
subtitle: {
display: true,
text: subtitle,
font: {
size: 16,
style: "italic"
},
color: textColor
},
legend: {
display: false
}
},
aspectRatio: 2
}
});
if (shouldFilter) {
const chartPeriodEl = document.getElementById("sr-chart-period");
chartPeriodEl.addEventListener("click", () => {
let filteredLabels, filteredData;
const chartPeriod = chartPeriodEl.value;
if (chartPeriod === "month") {
filteredLabels = labels.slice(0, 31);
filteredData = data.slice(0, 31);
} else if (chartPeriod === "quarter") {
filteredLabels = labels.slice(0, 91);
filteredData = data.slice(0, 91);
} else if (chartPeriod === "year") {
filteredLabels = labels.slice(0, 366);
filteredData = data.slice(0, 366);
} else {
filteredLabels = labels;
filteredData = data;
}
statsChart.data.labels = filteredLabels;
statsChart.data.datasets[0] = {
label: seriesTitle,
backgroundColor,
data: filteredData
};
statsChart.update();
});
}
document.getElementById(`${canvasId}Summary`).innerText = summary;
return statsChart;
}
// src/gui/tabs.tsx
var import_obsidian9 = require("obsidian");
var import_vhtml3 = __toESM(require_vhtml());
function createTabs(containerElement, tabs, activateTabId) {
const tabHeader = containerElement.createEl("div", {
attr: { class: "sr-tab-header" }
});
const tabContentContainers = {};
const tabButtons = {};
const tabStructure = {
header: tabHeader,
// Indicate that the first tab is active.
// This does not affect what tab is active in practice, it just reports the active tab.
activeTabId: Object.keys(tabs)[0],
buttons: tabButtons,
contentContainers: tabContentContainers,
contentGeneratorPromises: {}
};
let firstButton;
for (const tabId in tabs) {
const tab = tabs[tabId];
const button = tabHeader.createEl("button", {
attr: {
class: "sr-tab-header-button",
activateTab: "sr-tab-" + tabId
}
});
button.onclick = function(event) {
var _a;
const tabButton = this;
let maxWidth = 0;
let maxHeight = 0;
const tabHeader2 = tabButton.parentElement;
if (null === tabHeader2) {
throw new Error("Tab header is missing. Did not get a parent from tab button.");
}
const containerElement2 = tabHeader2.parentElement;
if (null === containerElement2) {
throw new Error(
"Container element is missing. Did not get a parent from tab header."
);
}
const tabContents = containerElement2.findAll("div.sr-tab-content");
const isMainSettingsModal = containerElement2.hasClass("vertical-tab-content");
for (const index in tabContents) {
const tabContent2 = tabContents[index];
if (!isMainSettingsModal) {
tabContent2.addClass("sr-tab-active");
if (tabContent2.offsetHeight > maxHeight) {
maxHeight = tabContent2.offsetHeight;
}
if (tabContent2.offsetWidth > maxWidth) {
maxWidth = tabContent2.offsetWidth;
}
}
tabContent2.removeClass("sr-tab-active");
}
const adjacentTabButtons = tabHeader2.findAll(".sr-tab-header-button");
for (const index in adjacentTabButtons) {
const tabButton2 = adjacentTabButtons[index];
tabButton2.removeClass("sr-tab-active");
}
tabButton.addClass("sr-tab-active");
const activateTabAttribute = tabButton.attributes.getNamedItem("activateTab");
if (null === activateTabAttribute) {
throw new Error("Tab button has no 'activateTab' HTML attribute! Murr!");
}
const activateTabId2 = activateTabAttribute.value;
const tabContent = document.getElementById(activateTabId2);
if (null === tabContent) {
throw new Error(
"No tab content was found with activate_tab_id '" + activateTabId2 + "'! Hmph!"
);
}
tabContent.addClass("sr-tab-active");
tabStructure.activeTabId = activateTabId2.replace(/^sr-tab-/, "");
(_a = tabContent.find(".sr-focus-element-on-tab-opening")) == null ? void 0 : _a.focus();
if (!isMainSettingsModal) {
tabContent.style.width = maxWidth + "px";
tabContent.style.height = maxHeight + "px";
}
event.preventDefault();
};
if (tab.icon) (0, import_obsidian9.setIcon)(button, tab.icon);
button.insertAdjacentHTML("beforeend", /* @__PURE__ */ (0, import_vhtml3.default)("span", { style: "padding-left: 5px;" }, tab.title));
tabButtons[tabId] = button;
tabContentContainers[tabId] = containerElement.createEl("div", {
attr: { class: "sr-tab-content", id: "sr-tab-" + tabId }
});
tabStructure.contentGeneratorPromises[tabId] = tab.contentGenerator(
tabContentContainers[tabId]
);
if (void 0 === firstButton) {
firstButton = button;
}
}
tabButtons[activateTabId].click();
return tabStructure;
}
// src/gui/settings.tsx
var applyDebounceTimer = 0;
function applySettingsUpdate(callback2) {
clearTimeout(applyDebounceTimer);
applyDebounceTimer = window.setTimeout(callback2, 512);
}
var SRSettingTab = class extends import_obsidian10.PluginSettingTab {
constructor(app, plugin) {
super(app, plugin);
this.lastPosition = {
scrollPosition: 0,
tabName: "main-flashcards"
};
this.plugin = plugin;
}
display() {
const { containerEl } = this;
containerEl.empty();
const header = containerEl.createEl("h4", {
text: `${t("SETTINGS_HEADER")}`
});
header.addClass("sr-centered");
this.tabStructure = createTabs(
containerEl,
{
"main-flashcards": {
title: t("FLASHCARDS"),
icon: "SpacedRepIcon",
contentGenerator: (containerElement) => this.tabFlashcards(containerElement)
},
"main-notes": {
title: t("NOTES"),
icon: "book-text",
contentGenerator: (containerElement) => this.tabNotes(containerElement)
},
"main-algorithm": {
title: t("SCHEDULING"),
icon: "calendar",
contentGenerator: (containerElement) => this.tabScheduling(containerElement)
},
"main-ui-preferences": {
title: t("UI"),
icon: "presentation",
contentGenerator: (containerElement) => this.tabUiPreferences(containerElement)
},
"main-statistics": {
title: t("STATS_TITLE"),
icon: "bar-chart-3",
contentGenerator: async (containerElement) => {
if (this.plugin.osrAppCore.cardStats == null) {
await this.plugin.sync();
}
this.statistics = new StatisticsView(
containerElement,
this.plugin.osrAppCore
);
this.statistics.render();
}
},
"main-help": {
title: t("HELP"),
icon: "badge-help",
contentGenerator: (containerElement) => this.tabHelp(containerElement)
}
},
this.lastPosition.tabName
);
this.tabStructure.contentGeneratorPromises[this.tabStructure.activeTabId].then(() => {
this.rememberLastPosition(containerEl);
});
}
hide() {
this.statistics.destroy();
this.containerEl.empty();
}
async tabFlashcards(containerEl) {
containerEl.createEl("h3", { text: t("GROUP_TAGS_FOLDERS") });
new import_obsidian10.Setting(containerEl).setName(t("FLASHCARD_TAGS")).setDesc(t("FLASHCARD_TAGS_DESC")).addTextArea(
(text) => text.setValue(this.plugin.data.settings.flashcardTags.join(" ")).onChange((value) => {
applySettingsUpdate(async () => {
this.plugin.data.settings.flashcardTags = value.split(/\s+/);
await this.plugin.savePluginData();
});
})
);
new import_obsidian10.Setting(containerEl).setName(t("CONVERT_FOLDERS_TO_DECKS")).setDesc(t("CONVERT_FOLDERS_TO_DECKS_DESC")).addToggle(
(toggle) => toggle.setValue(this.plugin.data.settings.convertFoldersToDecks).onChange(async (value) => {
this.plugin.data.settings.convertFoldersToDecks = value;
await this.plugin.savePluginData();
})
);
this.createSettingFoldersToIgnore(containerEl);
containerEl.createEl("h3", { text: t("GROUP_FLASHCARD_REVIEW") });
new import_obsidian10.Setting(containerEl).setName(t("BURY_SIBLINGS_TILL_NEXT_DAY")).setDesc(t("BURY_SIBLINGS_TILL_NEXT_DAY_DESC")).addToggle(
(toggle) => toggle.setValue(this.plugin.data.settings.burySiblingCards).onChange(async (value) => {
this.plugin.data.settings.burySiblingCards = value;
await this.plugin.savePluginData();
})
);
new import_obsidian10.Setting(containerEl).setName(t("REVIEW_CARD_ORDER_WITHIN_DECK")).addDropdown(
(dropdown) => dropdown.addOptions({
NewFirstSequential: t("REVIEW_CARD_ORDER_NEW_FIRST_SEQUENTIAL"),
DueFirstSequential: t("REVIEW_CARD_ORDER_DUE_FIRST_SEQUENTIAL"),
NewFirstRandom: t("REVIEW_CARD_ORDER_NEW_FIRST_RANDOM"),
DueFirstRandom: t("REVIEW_CARD_ORDER_DUE_FIRST_RANDOM"),
EveryCardRandomDeckAndCard: t("REVIEW_CARD_ORDER_RANDOM_DECK_AND_CARD")
}).setValue(this.plugin.data.settings.flashcardCardOrder).onChange(async (value) => {
this.plugin.data.settings.flashcardCardOrder = value;
await this.plugin.savePluginData();
this.display();
})
);
const deckOrderEnabled = this.plugin.data.settings.flashcardCardOrder != "EveryCardRandomDeckAndCard";
new import_obsidian10.Setting(containerEl).setName(t("REVIEW_DECK_ORDER")).addDropdown(
(dropdown) => dropdown.addOptions(
deckOrderEnabled ? {
// eslint-disable-next-line camelcase
PrevDeckComplete_Sequential: t(
"REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_SEQUENTIAL"
),
// eslint-disable-next-line camelcase
PrevDeckComplete_Random: t(
"REVIEW_DECK_ORDER_PREV_DECK_COMPLETE_RANDOM"
)
} : {
EveryCardRandomDeckAndCard: t(
"REVIEW_DECK_ORDER_RANDOM_DECK_AND_CARD"
)
}
).setValue(
deckOrderEnabled ? this.plugin.data.settings.flashcardDeckOrder : "EveryCardRandomDeckAndCard"
).setDisabled(!deckOrderEnabled).onChange(async (value) => {
this.plugin.data.settings.flashcardDeckOrder = value;
await this.plugin.savePluginData();
})
);
containerEl.createEl("h3", { text: t("GROUP_FLASHCARD_SEPARATORS") });
new import_obsidian10.Setting(containerEl).setName(t("CONVERT_HIGHLIGHTS_TO_CLOZES")).addToggle(
(toggle) => toggle.setValue(this.plugin.data.settings.convertHighlightsToClozes).onChange(async (value) => {
const hightlightPattern = "==[123;;]answer[;;hint]==";
const clozePatternSet = new Set(this.plugin.data.settings.clozePatterns);
if (value) {
clozePatternSet.add(hightlightPattern);
} else {
clozePatternSet.delete(hightlightPattern);
}
this.plugin.data.settings.clozePatterns = [...clozePatternSet];
this.plugin.data.settings.convertHighlightsToClozes = value;
await this.plugin.savePluginData();
this.display();
})
);
new import_obsidian10.Setting(containerEl).setName(t("CONVERT_BOLD_TEXT_TO_CLOZES")).addToggle(
(toggle) => toggle.setValue(this.plugin.data.settings.convertBoldTextToClozes).onChange(async (value) => {
const boldPattern = "**[123;;]answer[;;hint]**";
const clozePatternSet = new Set(this.plugin.data.settings.clozePatterns);
if (value) {
clozePatternSet.add(boldPattern);
} else {
clozePatternSet.delete(boldPattern);
}
this.plugin.data.settings.clozePatterns = [...clozePatternSet];
this.plugin.data.settings.convertBoldTextToClozes = value;
await this.plugin.savePluginData();
this.display();
})
);
new import_obsidian10.Setting(containerEl).setName(t("CONVERT_CURLY_BRACKETS_TO_CLOZES")).addToggle(
(toggle) => toggle.setValue(this.plugin.data.settings.convertCurlyBracketsToClozes).onChange(async (value) => {
const curlyBracketsPattern = "{{[123;;]answer[;;hint]}}";
const clozePatternSet = new Set(this.plugin.data.settings.clozePatterns);
if (value) {
clozePatternSet.add(curlyBracketsPattern);
} else {
clozePatternSet.delete(curlyBracketsPattern);
}
this.plugin.data.settings.clozePatterns = [...clozePatternSet];
this.plugin.data.settings.convertCurlyBracketsToClozes = value;
await this.plugin.savePluginData();
this.display();
})
);
const clozePatternsEl = new import_obsidian10.Setting(containerEl).setName(t("CLOZE_PATTERNS"));
clozePatternsEl.descEl.insertAdjacentHTML(
"beforeend",
t("CLOZE_PATTERNS_DESC", {
docsUrl: "https://www.stephenmwangi.com/obsidian-spaced-repetition/flashcards/cloze-cards/#cloze-types"
})
);
clozePatternsEl.addTextArea(
(text) => text.setPlaceholder(
"Example:\n==[123;;]answer[;;hint]==\n**[123;;]answer[;;hint]**\n{{[123;;]answer[;;hint]}}"
).setValue(this.plugin.data.settings.clozePatterns.join("\n")).onChange((value) => {
applySettingsUpdate(async () => {
const hightlightPattern = "==[123;;]answer[;;hint]==";
const boldPattern = "**[123;;]answer[;;hint]**";
const curlyBracketsPattern = "{{[123;;]answer[;;hint]}}";
const clozePatternSet = new Set(
value.split(/\n+/).map((v2) => v2.trim()).filter((v2) => v2)
);
if (clozePatternSet.has(hightlightPattern)) {
this.plugin.data.settings.convertHighlightsToClozes = true;
} else {
this.plugin.data.settings.convertHighlightsToClozes = false;
}
if (clozePatternSet.has(boldPattern)) {
this.plugin.data.settings.convertBoldTextToClozes = true;
} else {
this.plugin.data.settings.convertBoldTextToClozes = false;
}
if (clozePatternSet.has(curlyBracketsPattern)) {
this.plugin.data.settings.convertCurlyBracketsToClozes = true;
} else {
this.plugin.data.settings.convertCurlyBracketsToClozes = false;
}
this.plugin.data.settings.clozePatterns = [...clozePatternSet];
await this.plugin.savePluginData();
});
})
);
new import_obsidian10.Setting(containerEl).setName(t("INLINE_CARDS_SEPARATOR")).setDesc(t("FIX_SEPARATORS_MANUALLY_WARNING")).addText(
(text) => text.setValue(this.plugin.data.settings.singleLineCardSeparator).onChange((value) => {
applySettingsUpdate(async () => {
this.plugin.data.settings.singleLineCardSeparator = value;
await this.plugin.savePluginData();
});
})
).addExtraButton((button) => {
button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
this.plugin.data.settings.singleLineCardSeparator = DEFAULT_SETTINGS.singleLineCardSeparator;
await this.plugin.savePluginData();
this.display();
});
});
new import_obsidian10.Setting(containerEl).setName(t("INLINE_REVERSED_CARDS_SEPARATOR")).setDesc(t("FIX_SEPARATORS_MANUALLY_WARNING")).addText(
(text) => text.setValue(this.plugin.data.settings.singleLineReversedCardSeparator).onChange((value) => {
applySettingsUpdate(async () => {
this.plugin.data.settings.singleLineReversedCardSeparator = value;
await this.plugin.savePluginData();
});
})
).addExtraButton((button) => {
button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
this.plugin.data.settings.singleLineReversedCardSeparator = DEFAULT_SETTINGS.singleLineReversedCardSeparator;
await this.plugin.savePluginData();
this.display();
});
});
new import_obsidian10.Setting(containerEl).setName(t("MULTILINE_CARDS_SEPARATOR")).setDesc(t("FIX_SEPARATORS_MANUALLY_WARNING")).addText(
(text) => text.setValue(this.plugin.data.settings.multilineCardSeparator).onChange((value) => {
applySettingsUpdate(async () => {
this.plugin.data.settings.multilineCardSeparator = value;
await this.plugin.savePluginData();
});
})
).addExtraButton((button) => {
button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
this.plugin.data.settings.multilineCardSeparator = DEFAULT_SETTINGS.multilineCardSeparator;
await this.plugin.savePluginData();
this.display();
});
});
new import_obsidian10.Setting(containerEl).setName(t("MULTILINE_REVERSED_CARDS_SEPARATOR")).setDesc(t("FIX_SEPARATORS_MANUALLY_WARNING")).addText(
(text) => text.setValue(this.plugin.data.settings.multilineReversedCardSeparator).onChange((value) => {
applySettingsUpdate(async () => {
this.plugin.data.settings.multilineReversedCardSeparator = value;
await this.plugin.savePluginData();
});
})
).addExtraButton((button) => {
button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
this.plugin.data.settings.multilineReversedCardSeparator = DEFAULT_SETTINGS.multilineReversedCardSeparator;
await this.plugin.savePluginData();
this.display();
});
});
new import_obsidian10.Setting(containerEl).setName(t("MULTILINE_CARDS_END_MARKER")).setDesc(t("FIX_SEPARATORS_MANUALLY_WARNING")).addText(
(text) => text.setValue(this.plugin.data.settings.multilineCardEndMarker).onChange((value) => {
applySettingsUpdate(async () => {
this.plugin.data.settings.multilineCardEndMarker = value;
await this.plugin.savePluginData();
});
})
).addExtraButton((button) => {
button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
this.plugin.data.settings.multilineCardEndMarker = DEFAULT_SETTINGS.multilineCardEndMarker;
await this.plugin.savePluginData();
this.display();
});
});
}
async tabNotes(containerEl) {
containerEl.createEl("h3", { text: t("GROUP_TAGS_FOLDERS") });
new import_obsidian10.Setting(containerEl).setName(t("TAGS_TO_REVIEW")).setDesc(t("TAGS_TO_REVIEW_DESC")).addTextArea(
(text) => text.setValue(this.plugin.data.settings.tagsToReview.join(" ")).onChange((value) => {
applySettingsUpdate(async () => {
this.plugin.data.settings.tagsToReview = value.split(/\s+/);
await this.plugin.savePluginData();
});
})
);
this.createSettingFoldersToIgnore(containerEl);
containerEl.createEl("h3", { text: t("NOTES_REVIEW_QUEUE") });
new import_obsidian10.Setting(containerEl).setName(t("AUTO_NEXT_NOTE")).addToggle(
(toggle) => toggle.setValue(this.plugin.data.settings.autoNextNote).onChange(async (value) => {
this.plugin.data.settings.autoNextNote = value;
await this.plugin.savePluginData();
})
);
new import_obsidian10.Setting(containerEl).setName(t("OPEN_RANDOM_NOTE")).setDesc(t("OPEN_RANDOM_NOTE_DESC")).addToggle(
(toggle) => toggle.setValue(this.plugin.data.settings.openRandomNote).onChange(async (value) => {
this.plugin.data.settings.openRandomNote = value;
await this.plugin.savePluginData();
})
);
new import_obsidian10.Setting(containerEl).setName(t("REVIEW_PANE_ON_STARTUP")).addToggle(
(toggle) => toggle.setValue(this.plugin.data.settings.enableNoteReviewPaneOnStartup).onChange(async (value) => {
this.plugin.data.settings.enableNoteReviewPaneOnStartup = value;
await this.plugin.savePluginData();
})
);
new import_obsidian10.Setting(containerEl).setName(t("MAX_N_DAYS_REVIEW_QUEUE")).addText(
(text) => text.setValue(this.plugin.data.settings.maxNDaysNotesReviewQueue.toString()).onChange((value) => {
applySettingsUpdate(async () => {
const numValue = Number.parseInt(value);
if (!isNaN(numValue)) {
if (numValue < 1) {
new import_obsidian10.Notice(t("MIN_ONE_DAY"));
text.setValue(
this.plugin.data.settings.maxNDaysNotesReviewQueue.toString()
);
return;
}
this.plugin.data.settings.maxNDaysNotesReviewQueue = numValue;
await this.plugin.savePluginData();
} else {
new import_obsidian10.Notice(t("VALID_NUMBER_WARNING"));
}
});
})
).addExtraButton((button) => {
button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
this.plugin.data.settings.maxNDaysNotesReviewQueue = DEFAULT_SETTINGS.maxNDaysNotesReviewQueue;
await this.plugin.savePluginData();
this.display();
});
});
}
async createSettingFoldersToIgnore(containerEl) {
new import_obsidian10.Setting(containerEl).setName(t("FOLDERS_TO_IGNORE")).setDesc(t("FOLDERS_TO_IGNORE_DESC")).addTextArea(
(text) => text.setValue(this.plugin.data.settings.noteFoldersToIgnore.join("\n")).onChange((value) => {
applySettingsUpdate(async () => {
this.plugin.data.settings.noteFoldersToIgnore = value.split(/\n+/).map((v2) => v2.trim()).filter((v2) => v2);
await this.plugin.savePluginData();
this.display();
});
})
);
}
async tabUiPreferences(containerEl) {
containerEl.createEl("h3", { text: t("OBSIDIAN_INTEGRATION") });
new import_obsidian10.Setting(containerEl).setName(t("SHOW_RIBBON_ICON")).setDesc(t("SHOW_RIBBON_ICON_DESC")).addToggle(
(toggle) => toggle.setValue(this.plugin.data.settings.showRibbonIcon).onChange(async (value) => {
this.plugin.data.settings.showRibbonIcon = value;
await this.plugin.savePluginData();
this.plugin.showRibbonIcon(value);
})
);
new import_obsidian10.Setting(containerEl).setName(t("SHOW_STATUS_BAR")).setDesc(t("SHOW_STATUS_BAR_DESC")).addToggle(
(toggle) => toggle.setValue(this.plugin.data.settings.showStatusBar).onChange(async (value) => {
this.plugin.data.settings.showStatusBar = value;
await this.plugin.savePluginData();
this.plugin.showStatusBar(value);
})
);
new import_obsidian10.Setting(containerEl).setName(t("ENABLE_FILE_MENU_REVIEW_OPTIONS")).setDesc(t("ENABLE_FILE_MENU_REVIEW_OPTIONS_DESC")).addToggle(
(toggle) => toggle.setValue(!this.plugin.data.settings.disableFileMenuReviewOptions).onChange(async (value) => {
this.plugin.data.settings.disableFileMenuReviewOptions = !value;
await this.plugin.savePluginData();
this.plugin.showFileMenuItems(value);
})
);
containerEl.createEl("h3", { text: t("FLASHCARDS") });
new import_obsidian10.Setting(containerEl).setName(t("INITIALLY_EXPAND_SUBDECKS_IN_TREE")).setDesc(t("INITIALLY_EXPAND_SUBDECKS_IN_TREE_DESC")).addToggle(
(toggle) => toggle.setValue(this.plugin.data.settings.initiallyExpandAllSubdecksInTree).onChange(async (value) => {
this.plugin.data.settings.initiallyExpandAllSubdecksInTree = value;
await this.plugin.savePluginData();
})
);
new import_obsidian10.Setting(containerEl).setName(t("SHOW_CARD_CONTEXT")).setDesc(t("SHOW_CARD_CONTEXT_DESC")).addToggle(
(toggle) => toggle.setValue(this.plugin.data.settings.showContextInCards).onChange(async (value) => {
this.plugin.data.settings.showContextInCards = value;
await this.plugin.savePluginData();
})
);
new import_obsidian10.Setting(containerEl).setName(t("SHOW_INTERVAL_IN_REVIEW_BUTTONS")).setDesc(t("SHOW_INTERVAL_IN_REVIEW_BUTTONS_DESC")).addToggle(
(toggle) => toggle.setValue(this.plugin.data.settings.showIntervalInReviewButtons).onChange(async (value) => {
this.plugin.data.settings.showIntervalInReviewButtons = value;
await this.plugin.savePluginData();
})
);
new import_obsidian10.Setting(containerEl).setName(t("CARD_MODAL_HEIGHT_PERCENT")).setDesc(t("CARD_MODAL_SIZE_PERCENT_DESC")).addSlider(
(slider) => slider.setLimits(10, 100, 5).setValue(this.plugin.data.settings.flashcardHeightPercentage).setDynamicTooltip().onChange(async (value) => {
this.plugin.data.settings.flashcardHeightPercentage = value;
await this.plugin.savePluginData();
})
).addExtraButton((button) => {
button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
this.plugin.data.settings.flashcardHeightPercentage = DEFAULT_SETTINGS.flashcardHeightPercentage;
await this.plugin.savePluginData();
this.display();
});
});
new import_obsidian10.Setting(containerEl).setName(t("CARD_MODAL_WIDTH_PERCENT")).setDesc(t("CARD_MODAL_SIZE_PERCENT_DESC")).addSlider(
(slider) => slider.setLimits(10, 100, 5).setValue(this.plugin.data.settings.flashcardWidthPercentage).setDynamicTooltip().onChange(async (value) => {
this.plugin.data.settings.flashcardWidthPercentage = value;
await this.plugin.savePluginData();
})
).addExtraButton((button) => {
button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
this.plugin.data.settings.flashcardWidthPercentage = DEFAULT_SETTINGS.flashcardWidthPercentage;
await this.plugin.savePluginData();
this.display();
});
});
containerEl.createEl("h3", { text: t("GROUP_FLASHCARDS_NOTES") });
new import_obsidian10.Setting(containerEl).setName(t("FLASHCARD_EASY_LABEL")).setDesc(t("FLASHCARD_EASY_DESC")).addText(
(text) => text.setValue(this.plugin.data.settings.flashcardEasyText).onChange((value) => {
applySettingsUpdate(async () => {
this.plugin.data.settings.flashcardEasyText = value;
await this.plugin.savePluginData();
});
})
).addExtraButton((button) => {
button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
this.plugin.data.settings.flashcardEasyText = DEFAULT_SETTINGS.flashcardEasyText;
await this.plugin.savePluginData();
this.display();
});
});
new import_obsidian10.Setting(containerEl).setName(t("FLASHCARD_GOOD_LABEL")).setDesc(t("FLASHCARD_GOOD_DESC")).addText(
(text) => text.setValue(this.plugin.data.settings.flashcardGoodText).onChange((value) => {
applySettingsUpdate(async () => {
this.plugin.data.settings.flashcardGoodText = value;
await this.plugin.savePluginData();
});
})
).addExtraButton((button) => {
button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
this.plugin.data.settings.flashcardGoodText = DEFAULT_SETTINGS.flashcardGoodText;
await this.plugin.savePluginData();
this.display();
});
});
new import_obsidian10.Setting(containerEl).setName(t("FLASHCARD_HARD_LABEL")).setDesc(t("FLASHCARD_HARD_DESC")).addText(
(text) => text.setValue(this.plugin.data.settings.flashcardHardText).onChange((value) => {
applySettingsUpdate(async () => {
this.plugin.data.settings.flashcardHardText = value;
await this.plugin.savePluginData();
});
})
).addExtraButton((button) => {
button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
this.plugin.data.settings.flashcardHardText = DEFAULT_SETTINGS.flashcardHardText;
await this.plugin.savePluginData();
this.display();
});
});
new import_obsidian10.Setting(containerEl).setName(t("REVIEW_BUTTON_DELAY")).setDesc(t("REVIEW_BUTTON_DELAY_DESC")).addSlider(
(slider) => slider.setLimits(0, 5e3, 100).setValue(this.plugin.data.settings.reviewButtonDelay).setDynamicTooltip().onChange(async (value) => {
this.plugin.data.settings.reviewButtonDelay = value;
await this.plugin.savePluginData();
})
).addExtraButton((button) => {
button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
this.plugin.data.settings.reviewButtonDelay = DEFAULT_SETTINGS.reviewButtonDelay;
await this.plugin.savePluginData();
this.display();
});
});
}
async tabScheduling(containerEl) {
containerEl.createEl("h3", { text: t("ALGORITHM") });
const algoSettingEl = new import_obsidian10.Setting(containerEl).setName(t("ALGORITHM"));
algoSettingEl.descEl.insertAdjacentHTML(
"beforeend",
t("CHECK_ALGORITHM_WIKI", {
algoUrl: "https://www.stephenmwangi.com/obsidian-spaced-repetition/algorithms/"
})
);
algoSettingEl.addDropdown(
(dropdown) => dropdown.addOptions({
"SM-2-OSR": t("SM2_OSR_VARIANT")
}).setValue(this.plugin.data.settings.algorithm).onChange(async (value) => {
this.plugin.data.settings.algorithm = value;
await this.plugin.savePluginData();
})
);
new import_obsidian10.Setting(containerEl).setName(t("BASE_EASE")).setDesc(t("BASE_EASE_DESC")).addText(
(text) => text.setValue(this.plugin.data.settings.baseEase.toString()).onChange((value) => {
applySettingsUpdate(async () => {
const numValue = Number.parseInt(value);
if (!isNaN(numValue)) {
if (numValue < 130) {
new import_obsidian10.Notice(t("BASE_EASE_MIN_WARNING"));
text.setValue(this.plugin.data.settings.baseEase.toString());
return;
}
this.plugin.data.settings.baseEase = numValue;
await this.plugin.savePluginData();
} else {
new import_obsidian10.Notice(t("VALID_NUMBER_WARNING"));
}
});
})
).addExtraButton((button) => {
button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
this.plugin.data.settings.baseEase = DEFAULT_SETTINGS.baseEase;
await this.plugin.savePluginData();
this.display();
});
});
new import_obsidian10.Setting(containerEl).setName(t("LAPSE_INTERVAL_CHANGE")).setDesc(t("LAPSE_INTERVAL_CHANGE_DESC")).addSlider(
(slider) => slider.setLimits(1, 99, 1).setValue(this.plugin.data.settings.lapsesIntervalChange * 100).setDynamicTooltip().onChange(async (value) => {
this.plugin.data.settings.lapsesIntervalChange = value / 100;
await this.plugin.savePluginData();
})
).addExtraButton((button) => {
button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
this.plugin.data.settings.lapsesIntervalChange = DEFAULT_SETTINGS.lapsesIntervalChange;
await this.plugin.savePluginData();
this.display();
});
});
new import_obsidian10.Setting(containerEl).setName(t("EASY_BONUS")).setDesc(t("EASY_BONUS_DESC")).addText(
(text) => text.setValue((this.plugin.data.settings.easyBonus * 100).toString()).onChange((value) => {
applySettingsUpdate(async () => {
const numValue = Number.parseInt(value) / 100;
if (!isNaN(numValue)) {
if (numValue < 1) {
new import_obsidian10.Notice(t("EASY_BONUS_MIN_WARNING"));
text.setValue(
(this.plugin.data.settings.easyBonus * 100).toString()
);
return;
}
this.plugin.data.settings.easyBonus = numValue;
await this.plugin.savePluginData();
} else {
new import_obsidian10.Notice(t("VALID_NUMBER_WARNING"));
}
});
})
).addExtraButton((button) => {
button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
this.plugin.data.settings.easyBonus = DEFAULT_SETTINGS.easyBonus;
await this.plugin.savePluginData();
this.display();
});
});
new import_obsidian10.Setting(containerEl).setName(t("LOAD_BALANCE")).setDesc(t("LOAD_BALANCE_DESC")).addToggle(
(toggle) => toggle.setValue(this.plugin.data.settings.loadBalance).onChange(async (value) => {
this.plugin.data.settings.loadBalance = value;
await this.plugin.savePluginData();
})
);
new import_obsidian10.Setting(containerEl).setName(t("MAX_INTERVAL")).setDesc(t("MAX_INTERVAL_DESC")).addText(
(text) => text.setValue(this.plugin.data.settings.maximumInterval.toString()).onChange((value) => {
applySettingsUpdate(async () => {
const numValue = Number.parseInt(value);
if (!isNaN(numValue)) {
if (numValue < 1) {
new import_obsidian10.Notice(t("MAX_INTERVAL_MIN_WARNING"));
text.setValue(
this.plugin.data.settings.maximumInterval.toString()
);
return;
}
this.plugin.data.settings.maximumInterval = numValue;
await this.plugin.savePluginData();
} else {
new import_obsidian10.Notice(t("VALID_NUMBER_WARNING"));
}
});
})
).addExtraButton((button) => {
button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
this.plugin.data.settings.maximumInterval = DEFAULT_SETTINGS.maximumInterval;
await this.plugin.savePluginData();
this.display();
});
});
new import_obsidian10.Setting(containerEl).setName(t("MAX_LINK_CONTRIB")).setDesc(t("MAX_LINK_CONTRIB_DESC")).addSlider(
(slider) => slider.setLimits(0, 100, 1).setValue(this.plugin.data.settings.maxLinkFactor * 100).setDynamicTooltip().onChange(async (value) => {
this.plugin.data.settings.maxLinkFactor = value / 100;
await this.plugin.savePluginData();
})
).addExtraButton((button) => {
button.setIcon("reset").setTooltip(t("RESET_DEFAULT")).onClick(async () => {
this.plugin.data.settings.maxLinkFactor = DEFAULT_SETTINGS.maxLinkFactor;
await this.plugin.savePluginData();
this.display();
});
});
containerEl.createEl("h3", { text: t("GROUP_DATA_STORAGE") });
new import_obsidian10.Setting(containerEl).setName(t("GROUP_DATA_STORAGE")).setDesc(t("GROUP_DATA_STORAGE_DESC")).addDropdown(
(dropdown) => dropdown.addOptions({
NOTES: t("STORE_IN_NOTES")
}).setValue(this.plugin.data.settings.dataStore).onChange(async (value) => {
this.plugin.data.settings.dataStore = value;
await this.plugin.savePluginData();
})
);
new import_obsidian10.Setting(containerEl).setName(t("INLINE_SCHEDULING_COMMENTS")).setDesc(t("INLINE_SCHEDULING_COMMENTS_DESC")).addToggle(
(toggle) => toggle.setValue(this.plugin.data.settings.cardCommentOnSameLine).onChange(async (value) => {
this.plugin.data.settings.cardCommentOnSameLine = value;
await this.plugin.savePluginData();
})
);
}
async tabHelp(containerEl) {
containerEl.createEl("h3", { text: `${t("HELP")}` });
containerEl.createEl("p").insertAdjacentHTML(
"beforeend",
t("CHECK_WIKI", {
wikiUrl: "https://www.stephenmwangi.com/obsidian-spaced-repetition/"
})
);
containerEl.createEl("p").insertAdjacentHTML(
"beforeend",
t("GITHUB_DISCUSSIONS", {
discussionsUrl: "https://github.com/st3v3nmw/obsidian-spaced-repetition/discussions/"
})
);
containerEl.createEl("p").insertAdjacentHTML(
"beforeend",
t("GITHUB_ISSUES", {
issuesUrl: "https://github.com/st3v3nmw/obsidian-spaced-repetition/issues/"
})
);
containerEl.createEl("h3", { text: `${t("LOGGING")}` });
new import_obsidian10.Setting(containerEl).setName(t("DISPLAY_SCHEDULING_DEBUG_INFO")).addToggle(
(toggle) => toggle.setValue(this.plugin.data.settings.showSchedulingDebugMessages).onChange(async (value) => {
this.plugin.data.settings.showSchedulingDebugMessages = value;
await this.plugin.savePluginData();
})
);
new import_obsidian10.Setting(containerEl).setName(t("DISPLAY_PARSER_DEBUG_INFO")).addToggle(
(toggle) => toggle.setValue(this.plugin.data.settings.showParserDebugMessages).onChange(async (value) => {
this.plugin.data.settings.showParserDebugMessages = value;
setDebugParser(this.plugin.data.settings.showParserDebugMessages);
await this.plugin.savePluginData();
})
);
containerEl.createEl("h3", { text: t("GROUP_CONTRIBUTING") });
containerEl.createEl("p").insertAdjacentHTML(
"beforeend",
t("GITHUB_SOURCE_CODE", {
githubProjectUrl: "https://github.com/st3v3nmw/obsidian-spaced-repetition"
})
);
containerEl.createEl("p").insertAdjacentHTML(
"beforeend",
t("CODE_CONTRIBUTION_INFO", {
codeContributionUrl: "https://www.stephenmwangi.com/obsidian-spaced-repetition/contributing/#code"
})
);
containerEl.createEl("p").insertAdjacentHTML(
"beforeend",
t("TRANSLATION_CONTRIBUTION_INFO", {
translationContributionUrl: "https://www.stephenmwangi.com/obsidian-spaced-repetition/contributing/#translating"
})
);
}
rememberLastPosition(containerElement) {
const lastPosition = this.lastPosition;
this.tabStructure.buttons[lastPosition.tabName].click();
containerElement.scrollTo({
top: this.lastPosition.scrollPosition,
behavior: "auto"
});
containerElement.addEventListener("scroll", (_2) => {
this.lastPosition.scrollPosition = containerElement.scrollTop;
});
for (const tabName in this.tabStructure.buttons) {
const button = this.tabStructure.buttons[tabName];
button.onClickEvent((_2) => {
lastPosition.tabName = tabName;
});
}
}
};
// src/gui/sidebar.tsx
var OsrSidebar = class {
get app() {
return this.plugin.app;
}
constructor(plugin, settings, nextNoteReviewHandler) {
this.plugin = plugin;
this.settings = settings;
this.nextNoteReviewHandler = nextNoteReviewHandler;
}
redraw() {
this.reviewQueueListView.redraw();
}
getActiveLeaf(type) {
const leaves = this.app.workspace.getLeavesOfType(type);
if (leaves.length == 0) {
return this.app.workspace.getRightLeaf(false);
}
return leaves[0];
}
init() {
this.plugin.registerView(REVIEW_QUEUE_VIEW_TYPE, (leaf) => {
return this.reviewQueueListView = new ReviewQueueListView(
leaf,
this.nextNoteReviewHandler,
this.settings
);
});
}
async activateReviewQueueViewPanel() {
if (this.settings.enableNoteReviewPaneOnStartup) {
await this.getActiveLeaf(REVIEW_QUEUE_VIEW_TYPE).setViewState({
type: REVIEW_QUEUE_VIEW_TYPE,
active: true
});
}
}
async openReviewQueueView() {
const reviewQueueLeaf = this.getActiveLeaf(REVIEW_QUEUE_VIEW_TYPE);
this.app.workspace.revealLeaf(reviewQueueLeaf);
}
};
// src/icons/app-icon.ts
var import_obsidian11 = require("obsidian");
function appIcon() {
(0, import_obsidian11.addIcon)(
"SpacedRepIcon",
`
`
);
}
// src/next-note-review-handler.ts
var import_obsidian13 = require("obsidian");
// src/gui/review-deck-selection-modal.tsx
var import_obsidian12 = require("obsidian");
var ReviewDeckSelectionModal = class extends import_obsidian12.FuzzySuggestModal {
constructor(app, deckKeys) {
super(app);
this.deckKeys = [];
this.deckKeys = deckKeys;
}
getItems() {
return this.deckKeys;
}
getItemText(item) {
return item;
}
onChooseItem(deckKey, _2) {
this.close();
this.submitCallback(deckKey);
}
};
// src/next-note-review-handler.ts
var NextNoteReviewHandler = class {
get lastSelectedReviewDeck() {
return this._lastSelectedReviewDeck;
}
get noteReviewQueue() {
return this._noteReviewQueue;
}
constructor(app, settings, noteReviewQueue) {
this.app = app;
this.settings = settings;
this._noteReviewQueue = noteReviewQueue;
}
async autoReviewNextNote() {
if (this.settings.autoNextNote) {
if (!this._lastSelectedReviewDeck) {
const reviewDeckKeys = this._noteReviewQueue.reviewDeckNameList;
if (reviewDeckKeys.length > 0) this._lastSelectedReviewDeck = reviewDeckKeys[0];
else {
new import_obsidian13.Notice(t("ALL_CAUGHT_UP"));
return;
}
}
this.reviewNextNote(this._lastSelectedReviewDeck);
}
}
async reviewNextNoteModal() {
const reviewDeckNames = this._noteReviewQueue.reviewDeckNameList;
if (reviewDeckNames.length === 1) {
this.reviewNextNote(reviewDeckNames[0]);
} else {
const deckSelectionModal = new ReviewDeckSelectionModal(this.app, reviewDeckNames);
deckSelectionModal.submitCallback = (deckKey) => this.reviewNextNote(deckKey);
deckSelectionModal.open();
}
}
async reviewNextNote(deckKey) {
if (!this._noteReviewQueue.reviewDeckNameList.contains(deckKey)) {
new import_obsidian13.Notice(t("NO_DECK_EXISTS", { deckName: deckKey }));
return;
}
this._lastSelectedReviewDeck = deckKey;
const deck = this._noteReviewQueue.reviewDecks.get(deckKey);
const notefile = deck.determineNextNote(this.settings.openRandomNote);
if (notefile) {
await this.openNote(deckKey, notefile.tfile);
} else {
new import_obsidian13.Notice(t("ALL_CAUGHT_UP"));
}
}
async openNote(deckName, file) {
this._lastSelectedReviewDeck = deckName;
await this.app.workspace.getLeaf().openFile(file);
}
};
// src/note-review-deck.ts
var SchedNote = class {
constructor(note, dueUnix) {
this.note = note;
this.dueUnix = dueUnix;
}
isDue(todayUnix) {
return this.dueUnix <= todayUnix;
}
};
var NoteReviewDeck = class {
constructor(name) {
this._newNotes = [];
this._scheduledNotes = [];
this._dueNotesCount = 0;
this._deckName = name;
this._activeFolders = /* @__PURE__ */ new Set([this._deckName, t("TODAY")]);
}
get deckName() {
return this._deckName;
}
get newNotes() {
return this._newNotes;
}
get scheduledNotes() {
return this._scheduledNotes;
}
get dueNotesCount() {
return this._dueNotesCount;
}
get activeFolders() {
return this._activeFolders;
}
calcDueNotesCount(todayUnix) {
this._dueNotesCount = 0;
this.scheduledNotes.forEach((scheduledNote) => {
if (scheduledNote.isDue(todayUnix)) {
this._dueNotesCount++;
}
});
}
sortNotesByDateAndImportance(pageranks) {
this._newNotes = this.newNotes.sort(
(a2, b2) => (pageranks[b2.path] || 0) - (pageranks[a2.path] || 0)
);
this._scheduledNotes = this.scheduledNotes.sort((a2, b2) => {
const result = a2.dueUnix - b2.dueUnix;
if (result != 0) {
return result;
}
return (pageranks[b2.note.path] || 0) - (pageranks[a2.note.path] || 0);
});
}
determineNextNote(openRandomNote) {
const todayUnix = globalDateProvider.today.valueOf();
const dueNotes = this.scheduledNotes.filter((note) => note.isDue(todayUnix));
if (dueNotes.length > 0) {
const index = openRandomNote ? globalRandomNumberProvider.getInteger(0, dueNotes.length - 1) : 0;
return dueNotes[index].note;
}
if (this.newNotes.length > 0) {
const index = openRandomNote ? globalRandomNumberProvider.getInteger(0, this.newNotes.length - 1) : 0;
return this.newNotes[index];
}
return null;
}
};
// src/note-review-queue.ts
var NoteReviewQueue = class {
get reviewDecks() {
return this._reviewDecks;
}
get dueNotesCount() {
return this._dueNotesCount;
}
get reviewDeckNameList() {
return [...this._reviewDecks.keys()];
}
init() {
this._reviewDecks = /* @__PURE__ */ new Map();
}
calcDueNotesCount(todayUnix) {
this._dueNotesCount = 0;
this._reviewDecks.forEach((reviewDeck) => {
reviewDeck.calcDueNotesCount(todayUnix);
this._dueNotesCount += reviewDeck.dueNotesCount;
});
}
addNoteToQueue(noteFile, noteSchedule, matchedNoteTags) {
for (const matchedNoteTag of matchedNoteTags) {
if (!this.reviewDecks.has(matchedNoteTag)) {
this.reviewDecks.set(matchedNoteTag, new NoteReviewDeck(matchedNoteTag));
}
}
if (noteSchedule == null) {
for (const matchedNoteTag of matchedNoteTags) {
this.reviewDecks.get(matchedNoteTag).newNotes.push(noteFile);
}
} else {
for (const matchedNoteTag of matchedNoteTags) {
this.reviewDecks.get(matchedNoteTag).scheduledNotes.push(new SchedNote(noteFile, noteSchedule.dueDateAsUnix));
}
}
}
updateScheduleInfo(note, scheduleInfo) {
this.reviewDecks.forEach((reviewDeck) => {
let wasDueInDeck = false;
for (const scheduledNote of reviewDeck.scheduledNotes) {
if (scheduledNote.note.path === note.path) {
scheduledNote.dueUnix = scheduleInfo.dueDate.valueOf();
wasDueInDeck = true;
break;
}
}
if (!wasDueInDeck) {
reviewDeck.newNotes.splice(
reviewDeck.newNotes.findIndex((newNote) => newNote.path === note.path),
1
);
reviewDeck.scheduledNotes.push(new SchedNote(note, scheduleInfo.dueDate.valueOf()));
}
});
}
};
// src/plugin-data.ts
var DEFAULT_DATA = {
settings: DEFAULT_SETTINGS,
buryDate: "",
buryList: [],
historyDeck: null
};
// src/question-postponement-list.ts
var QuestionPostponementList = class {
constructor(plugin, settings, list) {
this.plugin = plugin;
this.settings = settings;
this.list = list;
}
async clearIfNewDay(data) {
const now2 = window.moment(Date.now());
const todayDate = now2.format("YYYY-MM-DD");
const isNewDay = todayDate !== data.buryDate;
if (isNewDay) {
data.buryDate = todayDate;
this.clear();
await this.write();
}
}
clear() {
this.list.splice(0);
}
add(question) {
if (!this.includes(question)) this.list.push(question.questionText.textHash);
}
includes(question) {
return this.list.includes(question.questionText.textHash);
}
async write() {
if (this.plugin == null) return;
await this.plugin.savePluginData();
}
};
// src/main.ts
var SRPlugin = class _SRPlugin extends import_obsidian14.Plugin {
constructor() {
super(...arguments);
this.ribbonIcon = null;
this.statusBar = null;
}
async onload() {
await this.loadPluginData();
const noteReviewQueue = new NoteReviewQueue();
this.nextNoteReviewHandler = new NextNoteReviewHandler(
this.app,
this.data.settings,
noteReviewQueue
);
this.osrSidebar = new OsrSidebar(this, this.data.settings, this.nextNoteReviewHandler);
this.osrSidebar.init();
this.app.workspace.onLayoutReady(async () => {
await this.osrSidebar.activateReviewQueueViewPanel();
setTimeout(async () => {
if (!this.osrAppCore.syncLock) {
await this.sync();
}
}, 2e3);
});
const questionPostponementList = new QuestionPostponementList(
this,
this.data.settings,
this.data.buryList
);
const osrNoteLinkInfoFinder = new ObsidianVaultNoteLinkInfoFinder(this.app.metadataCache);
this.osrAppCore = new OsrAppCore(this.app);
this.osrAppCore.init(
questionPostponementList,
osrNoteLinkInfoFinder,
this.data.settings,
this.onOsrVaultDataChanged.bind(this),
noteReviewQueue
);
appIcon();
this.showStatusBar(this.data.settings.showStatusBar);
this.showRibbonIcon(this.data.settings.showRibbonIcon);
this.showFileMenuItems(!this.data.settings.disableFileMenuReviewOptions);
this.addPluginCommands();
this.addSettingTab(new SRSettingTab(this.app, this));
}
showFileMenuItems(status) {
if (this.fileMenuHandler === void 0) {
this.fileMenuHandler = (menu, fileish) => {
if (fileish instanceof import_obsidian14.TFile && fileish.extension === "md") {
menu.addItem((item) => {
item.setTitle(
t("REVIEW_DIFFICULTY_FILE_MENU", {
difficulty: this.data.settings.flashcardEasyText
})
).setIcon("SpacedRepIcon").onClick(() => {
this.saveNoteReviewResponse(fileish, 0 /* Easy */);
});
});
menu.addItem((item) => {
item.setTitle(
t("REVIEW_DIFFICULTY_FILE_MENU", {
difficulty: this.data.settings.flashcardGoodText
})
).setIcon("SpacedRepIcon").onClick(() => {
this.saveNoteReviewResponse(fileish, 1 /* Good */);
});
});
menu.addItem((item) => {
item.setTitle(
t("REVIEW_DIFFICULTY_FILE_MENU", {
difficulty: this.data.settings.flashcardHardText
})
).setIcon("SpacedRepIcon").onClick(() => {
this.saveNoteReviewResponse(fileish, 2 /* Hard */);
});
});
}
};
}
if (status) {
this.registerEvent(this.app.workspace.on("file-menu", this.fileMenuHandler));
} else {
this.app.workspace.off("file-menu", this.fileMenuHandler);
}
}
addPluginCommands() {
this.addCommand({
id: "srs-note-review-open-note",
name: t("OPEN_NOTE_FOR_REVIEW"),
callback: async () => {
if (!this.osrAppCore.syncLock) {
await this.sync();
this.nextNoteReviewHandler.reviewNextNoteModal();
}
}
});
this.addCommand({
id: "srs-note-review-easy",
name: t("REVIEW_NOTE_DIFFICULTY_CMD", {
difficulty: this.data.settings.flashcardEasyText
}),
callback: () => {
const openFile = this.app.workspace.getActiveFile();
if (openFile && openFile.extension === "md") {
this.saveNoteReviewResponse(openFile, 0 /* Easy */);
}
}
});
this.addCommand({
id: "srs-note-review-good",
name: t("REVIEW_NOTE_DIFFICULTY_CMD", {
difficulty: this.data.settings.flashcardGoodText
}),
callback: () => {
const openFile = this.app.workspace.getActiveFile();
if (openFile && openFile.extension === "md") {
this.saveNoteReviewResponse(openFile, 1 /* Good */);
}
}
});
this.addCommand({
id: "srs-note-review-hard",
name: t("REVIEW_NOTE_DIFFICULTY_CMD", {
difficulty: this.data.settings.flashcardHardText
}),
callback: () => {
const openFile = this.app.workspace.getActiveFile();
if (openFile && openFile.extension === "md") {
this.saveNoteReviewResponse(openFile, 2 /* Hard */);
}
}
});
this.addCommand({
id: "srs-review-flashcards",
name: t("REVIEW_ALL_CARDS"),
callback: async () => {
if (!this.osrAppCore.syncLock) {
await this.sync();
this.openFlashcardModal(
this.osrAppCore.reviewableDeckTree,
this.osrAppCore.remainingDeckTree,
1 /* Review */
);
}
}
});
this.addCommand({
id: "srs-cram-flashcards",
name: t("CRAM_ALL_CARDS"),
callback: async () => {
await this.sync();
this.openFlashcardModal(
this.osrAppCore.reviewableDeckTree,
this.osrAppCore.reviewableDeckTree,
0 /* Cram */
);
}
});
this.addCommand({
id: "srs-review-flashcards-in-note",
name: t("REVIEW_CARDS_IN_NOTE"),
callback: async () => {
const openFile = this.app.workspace.getActiveFile();
if (openFile && openFile.extension === "md") {
this.openFlashcardModalForSingleNote(openFile, 1 /* Review */);
}
}
});
this.addCommand({
id: "srs-cram-flashcards-in-note",
name: t("CRAM_CARDS_IN_NOTE"),
callback: async () => {
const openFile = this.app.workspace.getActiveFile();
if (openFile && openFile.extension === "md") {
this.openFlashcardModalForSingleNote(openFile, 0 /* Cram */);
}
}
});
this.addCommand({
id: "srs-open-review-queue-view",
name: t("OPEN_REVIEW_QUEUE_VIEW"),
callback: async () => {
await this.osrSidebar.openReviewQueueView();
}
});
}
onunload() {
this.app.workspace.getLeavesOfType(REVIEW_QUEUE_VIEW_TYPE).forEach((leaf) => leaf.detach());
}
async openFlashcardModalForSingleNote(noteFile, reviewMode) {
const note = await this.loadNote(noteFile);
const deckTree = new Deck2("root", null);
note.appendCardsToDeck(deckTree);
const remainingDeckTree = DeckTreeFilter.filterForRemainingCards(
this.osrAppCore.questionPostponementList,
deckTree,
reviewMode
);
this.openFlashcardModal(deckTree, remainingDeckTree, reviewMode);
}
openFlashcardModal(fullDeckTree, remainingDeckTree, reviewMode) {
const deckIterator = _SRPlugin.createDeckTreeIterator(this.data.settings);
const reviewSequencer = new FlashcardReviewSequencer(
reviewMode,
deckIterator,
this.data.settings,
SrsAlgorithm.getInstance(),
this.osrAppCore.questionPostponementList,
this.osrAppCore.dueDateFlashcardHistogram
);
reviewSequencer.setDeckTree(fullDeckTree, remainingDeckTree);
new FlashcardModal(this.app, this, this.data.settings, reviewSequencer, reviewMode).open();
}
static createDeckTreeIterator(settings) {
let cardOrder = CardOrder[settings.flashcardCardOrder];
if (cardOrder === void 0) cardOrder = 2 /* DueFirstSequential */;
let deckOrder = DeckOrder[settings.flashcardDeckOrder];
if (deckOrder === void 0) deckOrder = 0 /* PrevDeckComplete_Sequential */;
const iteratorOrder = {
deckOrder,
cardOrder
};
return new DeckTreeIterator(iteratorOrder, null);
}
async sync() {
if (this.osrAppCore.syncLock) {
return;
}
const now2 = window.moment(Date.now());
this.osrAppCore.defaultTextDirection = this.getObsidianRtlSetting();
await this.osrAppCore.loadVault();
if (this.data.settings.showSchedulingDebugMessages) {
console.log(`SR: ${t("DECKS")}`, this.osrAppCore.reviewableDeckTree);
console.log(
"SR: " + t("SYNC_TIME_TAKEN", {
t: Date.now() - now2.valueOf()
})
);
}
}
onOsrVaultDataChanged() {
this.statusBar.setText(
t("STATUS_BAR", {
dueNotesCount: this.osrAppCore.noteReviewQueue.dueNotesCount,
dueFlashcardsCount: this.osrAppCore.remainingDeckTree.getCardCount(
2 /* All */,
true
)
})
);
if (this.data.settings.enableNoteReviewPaneOnStartup) this.osrSidebar.redraw();
}
async loadNote(noteFile) {
const loader = new NoteFileLoader(this.data.settings);
const srFile = this.createSrTFile(noteFile);
const folderTopicPath = TopicPath.getFolderPathFromFilename(
srFile,
this.data.settings
);
const note = await loader.load(
this.createSrTFile(noteFile),
this.getObsidianRtlSetting(),
folderTopicPath
);
if (note.hasChanged) {
note.writeNoteFile(this.data.settings);
}
return note;
}
getObsidianRtlSetting() {
const v2 = this.app.vault.getConfig("rightToLeft");
return convertToStringOrEmpty(v2) == "true" ? 2 /* Rtl */ : 1 /* Ltr */;
}
async saveNoteReviewResponse(note, response) {
const noteSrTFile = this.createSrTFile(note);
if (SettingsUtil.isPathInNoteIgnoreFolder(this.data.settings, note.path)) {
new import_obsidian14.Notice(t("NOTE_IN_IGNORED_FOLDER"));
return;
}
const tags = noteSrTFile.getAllTagsFromCache();
if (!SettingsUtil.isAnyTagANoteReviewTag(this.data.settings, tags)) {
new import_obsidian14.Notice(t("PLEASE_TAG_NOTE"));
return;
}
await this.osrAppCore.saveNoteReviewResponse(noteSrTFile, response, this.data.settings);
new import_obsidian14.Notice(t("RESPONSE_RECEIVED"));
if (this.data.settings.autoNextNote) {
this.nextNoteReviewHandler.autoReviewNextNote();
}
}
createSrTFile(note) {
return new SrTFile(this.app.vault, this.app.metadataCache, note);
}
async loadPluginData() {
const loadedData = await this.loadData();
if (loadedData == null ? void 0 : loadedData.settings) upgradeSettings(loadedData.settings);
this.data = Object.assign({}, DEFAULT_DATA, loadedData);
this.data.settings = Object.assign({}, DEFAULT_SETTINGS, this.data.settings);
setDebugParser(this.data.settings.showParserDebugMessages);
this.setupDataStoreAndAlgorithmInstances(this.data.settings);
}
setupDataStoreAndAlgorithmInstances(settings) {
DataStore.instance = new StoreInNotes(settings);
SrsAlgorithm.instance = new SrsAlgorithmOsr(settings);
DataStoreAlgorithm.instance = new DataStoreInNoteAlgorithmOsr(settings);
}
async savePluginData() {
await this.saveData(this.data);
}
showRibbonIcon(status) {
if (!this.ribbonIcon) {
this.ribbonIcon = this.addRibbonIcon("SpacedRepIcon", t("REVIEW_CARDS"), async () => {
if (!this.osrAppCore.syncLock) {
await this.sync();
this.openFlashcardModal(
this.osrAppCore.reviewableDeckTree,
this.osrAppCore.remainingDeckTree,
1 /* Review */
);
}
});
}
if (status) {
this.ribbonIcon.style.display = "";
} else {
this.ribbonIcon.style.display = "none";
}
}
showStatusBar(status) {
if (!this.statusBar) {
this.statusBar = this.addStatusBarItem();
this.statusBar.classList.add("mod-clickable");
this.statusBar.setAttribute("aria-label", t("OPEN_NOTE_FOR_REVIEW"));
this.statusBar.setAttribute("aria-label-position", "top");
this.statusBar.addEventListener("click", async () => {
if (!this.osrAppCore.syncLock) {
await this.sync();
this.nextNoteReviewHandler.reviewNextNoteModal();
}
});
}
if (status) {
this.statusBar.style.display = "";
} else {
this.statusBar.style.display = "none";
}
}
};
/*! Bundled license information:
moment/moment.js:
(*! moment.js *)
(*! version : 2.30.1 *)
(*! authors : Tim Wood, Iskren Chernev, Moment.js contributors *)
(*! license : MIT *)
(*! momentjs.com *)
@kurkle/color/dist/color.esm.js:
(*!
* @kurkle/color v0.3.2
* https://github.com/kurkle/color#readme
* (c) 2023 Jukka Kurkela
* Released under the MIT License
*)
chart.js/dist/chunks/helpers.segment.js:
(*!
* Chart.js v4.4.4
* https://www.chartjs.org
* (c) 2024 Chart.js Contributors
* Released under the MIT License
*)
chart.js/dist/chart.js:
(*!
* Chart.js v4.4.4
* https://www.chartjs.org
* (c) 2024 Chart.js Contributors
* Released under the MIT License
*)
*/
/* nosourcemap */