diff --git a/build/main.js b/build/main.js new file mode 100644 index 0000000..41e11df --- /dev/null +++ b/build/main.js @@ -0,0 +1,371 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ESBUILD +if you want to view the source, please visit the github repository of this plugin +*/ + +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; +}; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); +var __async = (__this, __arguments, generator) => { + return new Promise((resolve, reject) => { + var fulfilled = (value) => { + try { + step(generator.next(value)); + } catch (e) { + reject(e); + } + }; + var rejected = (value) => { + try { + step(generator.throw(value)); + } catch (e) { + reject(e); + } + }; + var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected); + step((generator = generator.apply(__this, __arguments)).next()); + }); +}; + +// src/main.ts +var main_exports = {}; +__export(main_exports, { + default: () => HeatmapCalendar +}); +module.exports = __toCommonJS(main_exports); + +// src/defaults.ts +var DEFAULT_COLORS = { default: ["#c6e48b", "#7bc96f", "#49af5d", "#2e8840", "#196127"] }; +var DEFAULT_SETTINGS = { + year: (/* @__PURE__ */ new Date()).getFullYear(), + colors: DEFAULT_COLORS, + entries: [], + showCurrentDayBorder: true, + intensity: { + default: 4, + startScale: 1, + endScale: 5 + } +}; + +// src/main.ts +var import_obsidian2 = require("obsidian"); + +// src/settings.ts +var import_obsidian = require("obsidian"); +var HeatmapCalendarSettingsTab = class extends import_obsidian.PluginSettingTab { + constructor(app, plugin, settings) { + super(app, plugin); + this.plugin = plugin; + this.settings = settings; + } + deleteColorMap(key) { + return __async(this, null, function* () { + delete this.settings.colors[key]; + yield this.plugin.saveSettings(this.settings); + this.display(); + }); + } + displayColorSettings() { + const { containerEl } = this; + containerEl.createEl("h3", { text: "Colors" }); + this.displayColorHelp(containerEl); + for (const [key, colors] of Object.entries(this.settings.colors)) { + const colorEntryContainer = containerEl.createDiv({ + cls: "heatmap-calendar-settings-colors__container" + }); + const colorDataContainer = colorEntryContainer.createDiv({ + cls: "heatmap-calendar-settings-colors__data-container" + }); + colorDataContainer.createEl("h4", { text: key }); + const colorRow = colorDataContainer.createDiv({ cls: "heatmap-calendar-settings-colors__row" }); + const colorsContainer = colorRow.createDiv({ + cls: "heatmap-calendar-settings-colors__color-container" + }); + for (const color of colors) { + colorsContainer.createEl("div", { + cls: "heatmap-calendar-settings-colors__color-box", + attr: { + style: `background-color: ${color}` + } + }); + colorsContainer.createEl("pre", { + cls: "heatmap-calendar-settings-colors__color-name", + text: color + }); + } + if (key !== "default") { + const deleteColorButton = colorEntryContainer.createEl("button", { + cls: "mod-warning heatmap-calendar-settings-colors__delete" + }); + (0, import_obsidian.setIcon)(deleteColorButton, "trash"); + deleteColorButton.addEventListener("click", () => this.deleteColorMap(key)); + } + } + this.displayColorInput(containerEl); + } + displayColorInput(parent) { + const inputContainer = parent.createDiv({ + cls: "heatmap-calendar-settings-colors__new-color-input-container" + }); + const colorNameInput = inputContainer.createEl("input", { + cls: "heatmap-calendar-settings-colors__new-color-input-name", + attr: { placeholder: "Color name", type: "text" } + }); + const colorValueInput = inputContainer.createEl("input", { + cls: "heatmap-calendar-settings-colors__new-color-input-value", + attr: { placeholder: "Colors array", type: "text" } + }); + const addColorButton = inputContainer.createEl("button", { + cls: "mod-cta heatmap-calendar-settings-colors__new-color-button" + }); + (0, import_obsidian.setIcon)(addColorButton, "plus"); + addColorButton.addEventListener("click", () => __async(this, null, function* () { + const name = this.validate( + colorNameInput, + (value) => value != null ? value : void 0, + "Please input a name for your color" + ); + const colors = this.validate( + colorValueInput, + (value) => { + var _a; + return (_a = this.parseColors(value)) != null ? _a : void 0; + }, + "Color is not a valid JSON array of colors" + ); + if (name !== void 0 && colors !== void 0) { + this.settings.colors[name] = colors; + yield this.plugin.saveSettings(this.settings); + this.display(); + } + })); + } + displayColorHelp(parent) { + parent.createEl("p", { + text: "Add lists of colors which will be globally available on your heatmaps." + }); + parent.createEl("p", { + text: "You can use those colors by referencing their name in your heatmap render settings." + }); + } + validate(input, validator, msg) { + const value = validator(input.value); + if (value !== void 0) { + input.classList.add("has-error"); + input.setCustomValidity(msg); + } else { + input.setCustomValidity(""); + } + input.reportValidity(); + return value; + } + parseColors(value) { + const colorRegex = /^(#[0-9a-f]{3,6}|rgba?\(\s*\d+%?\s*,\s*\d+%?\s*,\s*\d+%?\s*(,\s*\d+(\.\d+)?%?)?\s*\))$/i; + try { + const data = JSON.parse(value); + return Array.isArray(data) && data.every((color) => colorRegex.test(color)) ? data : void 0; + } catch (e) { + return void 0; + } + } + display() { + const { containerEl } = this; + containerEl.empty(); + containerEl.createEl("h2", { text: "Heatmap Calendar Settings" }); + this.displayColorSettings(); + console.log("settings", this.settings); + } +}; + +// src/main.ts +var HeatmapCalendar = class extends import_obsidian2.Plugin { + /** + * Returns a number representing how many days into the year the supplied date is. + * Example: first of january is 1, third of february is 34 (31+3) + * @param date + */ + getHowManyDaysIntoYear(date) { + return (Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()) - Date.UTC(date.getUTCFullYear(), 0, 0)) / 24 / 60 / 60 / 1e3; + } + getHowManyDaysIntoYearLocal(date) { + return (Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()) - Date.UTC(date.getFullYear(), 0, 0)) / 24 / 60 / 60 / 1e3; + } + /** + * Removes HTMLElements passed as entry.content and outside of the displayed year from rendering above the calendar + */ + removeHtmlElementsNotInYear(entries, year) { + entries.filter((e) => new Date(e.date).getFullYear() !== year).forEach((e) => e.content instanceof HTMLElement && e.content.remove()); + } + clamp(input, min, max) { + return input < min ? min : input > max ? max : input; + } + map(current, inMin, inMax, outMin, outMax) { + const mapped = (current - inMin) * (outMax - outMin) / (inMax - inMin) + outMin; + return this.clamp(mapped, outMin, outMax); + } + onload() { + return __async(this, null, function* () { + const settings = yield this.loadSettings(); + this.addSettingTab(new HeatmapCalendarSettingsTab(this.app, this, settings)); + window.renderHeatmapCalendar = (el, calendarData) => { + var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p; + const year = (_a = calendarData.year) != null ? _a : settings.year; + const colors = typeof calendarData.colors === "string" ? settings.colors[calendarData.colors] ? { [calendarData.colors]: settings.colors[calendarData.colors] } : settings.colors : (_b = calendarData.colors) != null ? _b : settings.colors; + this.removeHtmlElementsNotInYear((_c = calendarData.entries) != null ? _c : [], year); + const calEntries = (_e = (_d = calendarData.entries) == null ? void 0 : _d.filter( + (entry) => (/* @__PURE__ */ new Date(entry.date + "T00:00")).getFullYear() === year + )) != null ? _e : settings.entries; + const showCurrentDayBorder = (_f = calendarData.showCurrentDayBorder) != null ? _f : settings.showCurrentDayBorder; + const defaultEntryIntensity = (_i = (_g = calendarData.intensity) == null ? void 0 : _g.default) != null ? _i : (_h = settings.intensity) == null ? void 0 : _h.default; + const intensities = calEntries.map((entry) => entry.intensity).filter((intensity) => intensity !== void 0); + const minimumIntensity = Math.min(settings.intensity.startScale, ...intensities); + const maximumIntensity = Math.max(settings.intensity.endScale, ...intensities); + const intensityScaleStart = (_k = (_j = calendarData.intensity) == null ? void 0 : _j.startScale) != null ? _k : minimumIntensity; + const intensityScaleEnd = (_m = (_l = calendarData.intensity) == null ? void 0 : _l.endScale) != null ? _m : maximumIntensity; + const mappedEntries = []; + calEntries.forEach((e) => { + var _a2; + const newEntry = __spreadValues({ + intensity: defaultEntryIntensity + }, e); + const colorIntensities = typeof colors === "string" ? settings.colors[colors] : (_a2 = colors[e.color]) != null ? _a2 : colors[Object.keys(colors)[0]]; + const numOfColorIntensities = Object.keys(colorIntensities).length; + if (minimumIntensity === maximumIntensity && intensityScaleStart === intensityScaleEnd) + newEntry.intensity = numOfColorIntensities; + else + newEntry.intensity = Math.round( + this.map( + newEntry.intensity, + intensityScaleStart, + intensityScaleEnd, + 1, + numOfColorIntensities + ) + ); + mappedEntries[this.getHowManyDaysIntoYear(new Date(e.date))] = newEntry; + }); + const firstDayOfYear = new Date(Date.UTC(year, 0, 1)); + let numberOfEmptyDaysBeforeYearBegins = (firstDayOfYear.getUTCDay() + 6) % 7; + const boxes = []; + while (numberOfEmptyDaysBeforeYearBegins) { + boxes.push({ backgroundColor: "transparent" }); + numberOfEmptyDaysBeforeYearBegins--; + } + const lastDayOfYear = new Date(Date.UTC(year, 11, 31)); + const numberOfDaysInYear = this.getHowManyDaysIntoYear(lastDayOfYear); + const todaysDayNumberLocal = this.getHowManyDaysIntoYearLocal(/* @__PURE__ */ new Date()); + for (let day = 1; day <= numberOfDaysInYear; day++) { + const box = { classNames: [] }; + if (day === todaysDayNumberLocal && showCurrentDayBorder) (_n = box.classNames) == null ? void 0 : _n.push("today"); + if (mappedEntries[day]) { + (_o = box.classNames) == null ? void 0 : _o.push("hasData"); + const entry = mappedEntries[day]; + box.date = entry.date; + if (entry.content) box.content = entry.content.toString(); + const currentDayColors = entry.color ? colors[entry.color] : colors[Object.keys(colors)[0]]; + box.backgroundColor = currentDayColors[entry.intensity - 1]; + } else (_p = box.classNames) == null ? void 0 : _p.push("isEmpty"); + boxes.push(box); + } + const heatmapCalendarGraphDiv = createDiv({ + cls: "heatmap-calendar-graph", + parent: el + }); + createDiv({ + cls: "heatmap-calendar-year", + text: String(year).slice(2), + parent: heatmapCalendarGraphDiv + }); + const heatmapCalendarMonthsUl = createEl("ul", { + cls: "heatmap-calendar-months", + parent: heatmapCalendarGraphDiv + }); + createEl("li", { text: "Jan", parent: heatmapCalendarMonthsUl }); + createEl("li", { text: "Feb", parent: heatmapCalendarMonthsUl }); + createEl("li", { text: "Mar", parent: heatmapCalendarMonthsUl }); + createEl("li", { text: "Apr", parent: heatmapCalendarMonthsUl }); + createEl("li", { text: "May", parent: heatmapCalendarMonthsUl }); + createEl("li", { text: "Jun", parent: heatmapCalendarMonthsUl }); + createEl("li", { text: "Jul", parent: heatmapCalendarMonthsUl }); + createEl("li", { text: "Aug", parent: heatmapCalendarMonthsUl }); + createEl("li", { text: "Sep", parent: heatmapCalendarMonthsUl }); + createEl("li", { text: "Oct", parent: heatmapCalendarMonthsUl }); + createEl("li", { text: "Nov", parent: heatmapCalendarMonthsUl }); + createEl("li", { text: "Dec", parent: heatmapCalendarMonthsUl }); + const heatmapCalendarDaysUl = createEl("ul", { + cls: "heatmap-calendar-days", + parent: heatmapCalendarGraphDiv + }); + createEl("li", { text: "Mon", parent: heatmapCalendarDaysUl }); + createEl("li", { text: "Tue", parent: heatmapCalendarDaysUl }); + createEl("li", { text: "Wed", parent: heatmapCalendarDaysUl }); + createEl("li", { text: "Thu", parent: heatmapCalendarDaysUl }); + createEl("li", { text: "Fri", parent: heatmapCalendarDaysUl }); + createEl("li", { text: "Sat", parent: heatmapCalendarDaysUl }); + createEl("li", { text: "Sun", parent: heatmapCalendarDaysUl }); + const heatmapCalendarBoxesUl = createEl("ul", { + cls: "heatmap-calendar-boxes", + parent: heatmapCalendarGraphDiv + }); + boxes.forEach((e) => { + const entry = createEl("li", { + attr: __spreadValues(__spreadValues({}, e.backgroundColor && { style: `background-color: ${e.backgroundColor};` }), e.date && { "data-date": e.date }), + cls: e.classNames, + parent: heatmapCalendarBoxesUl + }); + createSpan({ + cls: "heatmap-calendar-content", + parent: entry, + text: e.content + }); + }); + }; + }); + } + onunload() { + } + loadSettings() { + return __async(this, null, function* () { + const storedSettings = yield this.loadData(); + console.log("stored settings:", storedSettings); + const settings = Object.assign({}, DEFAULT_SETTINGS, storedSettings); + console.log("settings:", settings); + return settings; + }); + } + saveSettings(settings) { + return __async(this, null, function* () { + yield this.saveData(settings); + }); + } +}; +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/main.ts", "../src/defaults.ts", "../src/settings.ts"],
  "sourcesContent": ["import { DEFAULT_SETTINGS } from \"defaults\";\nimport { Box, CalendarData, CalendarSettings, Entry } from \"model\";\nimport { Plugin } from \"obsidian\";\nimport HeatmapCalendarSettingsTab from \"settings\";\n\ndeclare global {\n\tinterface Window {\n\t\trenderHeatmapCalendar: any;\n\t}\n}\n\nexport default class HeatmapCalendar extends Plugin {\n\t/**\n\t * Returns a number representing how many days into the year the supplied date is.\n\t * Example: first of january is 1, third of february is 34 (31+3)\n\t * @param date\n\t */\n\n\tgetHowManyDaysIntoYear(date: Date): number {\n\t\treturn (\n\t\t\t(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()) -\n\t\t\t\tDate.UTC(date.getUTCFullYear(), 0, 0)) /\n\t\t\t24 /\n\t\t\t60 /\n\t\t\t60 /\n\t\t\t1000\n\t\t);\n\t}\n\tgetHowManyDaysIntoYearLocal(date: Date): number {\n\t\treturn (\n\t\t\t(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()) -\n\t\t\t\tDate.UTC(date.getFullYear(), 0, 0)) /\n\t\t\t24 /\n\t\t\t60 /\n\t\t\t60 /\n\t\t\t1000\n\t\t);\n\t}\n\t/**\n\t * Removes HTMLElements passed as entry.content and outside of the displayed year from rendering above the calendar\n\t */\n\tremoveHtmlElementsNotInYear(entries: Entry[], year: number): void {\n\t\tentries\n\t\t\t.filter((e: Entry) => new Date(e.date).getFullYear() !== year)\n\t\t\t.forEach((e: Entry) => e.content instanceof HTMLElement && e.content.remove());\n\t}\n\n\tclamp(input: number, min: number, max: number): number {\n\t\treturn input < min ? min : input > max ? max : input;\n\t}\n\n\tmap(current: number, inMin: number, inMax: number, outMin: number, outMax: number): number {\n\t\tconst mapped: number = ((current - inMin) * (outMax - outMin)) / (inMax - inMin) + outMin;\n\t\treturn this.clamp(mapped, outMin, outMax);\n\t}\n\n\tasync onload(): Promise<void> {\n\t\tconst settings = await this.loadSettings();\n\n\t\tthis.addSettingTab(new HeatmapCalendarSettingsTab(this.app, this, settings));\n\n\t\twindow.renderHeatmapCalendar = (el: HTMLElement, calendarData: Partial<CalendarData>): void => {\n\t\t\tconst year = calendarData.year ?? settings.year;\n\t\t\tconst colors =\n\t\t\t\ttypeof calendarData.colors === \"string\"\n\t\t\t\t\t? settings.colors[calendarData.colors]\n\t\t\t\t\t\t? { [calendarData.colors]: settings.colors[calendarData.colors] }\n\t\t\t\t\t\t: settings.colors\n\t\t\t\t\t: calendarData.colors ?? settings.colors;\n\n\t\t\tthis.removeHtmlElementsNotInYear(calendarData.entries ?? [], year);\n\n\t\t\tconst calEntries =\n\t\t\t\tcalendarData.entries?.filter(\n\t\t\t\t\t(entry: Entry) => new Date(entry.date + \"T00:00\").getFullYear() === year,\n\t\t\t\t) ?? settings.entries;\n\n\t\t\tconst showCurrentDayBorder = calendarData.showCurrentDayBorder ?? settings.showCurrentDayBorder;\n\t\t\tconst defaultEntryIntensity = calendarData.intensity?.default ?? settings.intensity?.default;\n\n\t\t\tconst intensities: number[] = calEntries\n\t\t\t\t.map((entry: Entry) => entry.intensity)\n\t\t\t\t.filter((intensity): intensity is number => intensity !== undefined);\n\t\t\tconst minimumIntensity = Math.min(settings.intensity.startScale, ...intensities);\n\t\t\tconst maximumIntensity = Math.max(settings.intensity.endScale, ...intensities);\n\t\t\tconst intensityScaleStart = calendarData.intensity?.startScale ?? minimumIntensity;\n\t\t\tconst intensityScaleEnd = calendarData.intensity?.endScale ?? maximumIntensity;\n\n\t\t\tconst mappedEntries: Entry[] = [];\n\t\t\tcalEntries.forEach((e: Entry) => {\n\t\t\t\tconst newEntry = {\n\t\t\t\t\tintensity: defaultEntryIntensity,\n\t\t\t\t\t...e,\n\t\t\t\t};\n\t\t\t\tconst colorIntensities =\n\t\t\t\t\ttypeof colors === \"string\"\n\t\t\t\t\t\t? settings.colors[colors]\n\t\t\t\t\t\t: colors[e.color] ?? colors[Object.keys(colors)[0]];\n\n\t\t\t\tconst numOfColorIntensities = Object.keys(colorIntensities).length;\n\n\t\t\t\tif (minimumIntensity === maximumIntensity && intensityScaleStart === intensityScaleEnd)\n\t\t\t\t\tnewEntry.intensity = numOfColorIntensities;\n\t\t\t\telse\n\t\t\t\t\tnewEntry.intensity = Math.round(\n\t\t\t\t\t\tthis.map(\n\t\t\t\t\t\t\tnewEntry.intensity,\n\t\t\t\t\t\t\tintensityScaleStart,\n\t\t\t\t\t\t\tintensityScaleEnd,\n\t\t\t\t\t\t\t1,\n\t\t\t\t\t\t\tnumOfColorIntensities,\n\t\t\t\t\t\t),\n\t\t\t\t\t);\n\n\t\t\t\tmappedEntries[this.getHowManyDaysIntoYear(new Date(e.date))] = newEntry;\n\t\t\t});\n\n\t\t\tconst firstDayOfYear = new Date(Date.UTC(year, 0, 1));\n\t\t\tlet numberOfEmptyDaysBeforeYearBegins = (firstDayOfYear.getUTCDay() + 6) % 7;\n\n\t\t\tconst boxes: Array<Box> = [];\n\n\t\t\twhile (numberOfEmptyDaysBeforeYearBegins) {\n\t\t\t\tboxes.push({ backgroundColor: \"transparent\" });\n\t\t\t\tnumberOfEmptyDaysBeforeYearBegins--;\n\t\t\t}\n\t\t\tconst lastDayOfYear = new Date(Date.UTC(year, 11, 31));\n\t\t\tconst numberOfDaysInYear = this.getHowManyDaysIntoYear(lastDayOfYear); //eg 365 or 366\n\t\t\tconst todaysDayNumberLocal = this.getHowManyDaysIntoYearLocal(new Date());\n\n\t\t\tfor (let day = 1; day <= numberOfDaysInYear; day++) {\n\t\t\t\tconst box: Box = { classNames: [] };\n\n\t\t\t\tif (day === todaysDayNumberLocal && showCurrentDayBorder) box.classNames?.push(\"today\");\n\n\t\t\t\tif (mappedEntries[day]) {\n\t\t\t\t\tbox.classNames?.push(\"hasData\");\n\t\t\t\t\tconst entry = mappedEntries[day];\n\n\t\t\t\t\tbox.date = entry.date;\n\n\t\t\t\t\tif (entry.content) box.content = entry.content.toString();\n\n\t\t\t\t\tconst currentDayColors = entry.color\n\t\t\t\t\t\t? colors[entry.color]\n\t\t\t\t\t\t: colors[Object.keys(colors)[0]];\n\t\t\t\t\tbox.backgroundColor = currentDayColors[(entry.intensity as number) - 1];\n\t\t\t\t} else box.classNames?.push(\"isEmpty\");\n\t\t\t\tboxes.push(box);\n\t\t\t}\n\n\t\t\tconst heatmapCalendarGraphDiv = createDiv({\n\t\t\t\tcls: \"heatmap-calendar-graph\",\n\t\t\t\tparent: el,\n\t\t\t});\n\n\t\t\tcreateDiv({\n\t\t\t\tcls: \"heatmap-calendar-year\",\n\t\t\t\ttext: String(year).slice(2),\n\t\t\t\tparent: heatmapCalendarGraphDiv,\n\t\t\t});\n\n\t\t\tconst heatmapCalendarMonthsUl = createEl(\"ul\", {\n\t\t\t\tcls: \"heatmap-calendar-months\",\n\t\t\t\tparent: heatmapCalendarGraphDiv,\n\t\t\t});\n\n\t\t\tcreateEl(\"li\", { text: \"Jan\", parent: heatmapCalendarMonthsUl });\n\t\t\tcreateEl(\"li\", { text: \"Feb\", parent: heatmapCalendarMonthsUl });\n\t\t\tcreateEl(\"li\", { text: \"Mar\", parent: heatmapCalendarMonthsUl });\n\t\t\tcreateEl(\"li\", { text: \"Apr\", parent: heatmapCalendarMonthsUl });\n\t\t\tcreateEl(\"li\", { text: \"May\", parent: heatmapCalendarMonthsUl });\n\t\t\tcreateEl(\"li\", { text: \"Jun\", parent: heatmapCalendarMonthsUl });\n\t\t\tcreateEl(\"li\", { text: \"Jul\", parent: heatmapCalendarMonthsUl });\n\t\t\tcreateEl(\"li\", { text: \"Aug\", parent: heatmapCalendarMonthsUl });\n\t\t\tcreateEl(\"li\", { text: \"Sep\", parent: heatmapCalendarMonthsUl });\n\t\t\tcreateEl(\"li\", { text: \"Oct\", parent: heatmapCalendarMonthsUl });\n\t\t\tcreateEl(\"li\", { text: \"Nov\", parent: heatmapCalendarMonthsUl });\n\t\t\tcreateEl(\"li\", { text: \"Dec\", parent: heatmapCalendarMonthsUl });\n\n\t\t\tconst heatmapCalendarDaysUl = createEl(\"ul\", {\n\t\t\t\tcls: \"heatmap-calendar-days\",\n\t\t\t\tparent: heatmapCalendarGraphDiv,\n\t\t\t});\n\n\t\t\tcreateEl(\"li\", { text: \"Mon\", parent: heatmapCalendarDaysUl });\n\t\t\tcreateEl(\"li\", { text: \"Tue\", parent: heatmapCalendarDaysUl });\n\t\t\tcreateEl(\"li\", { text: \"Wed\", parent: heatmapCalendarDaysUl });\n\t\t\tcreateEl(\"li\", { text: \"Thu\", parent: heatmapCalendarDaysUl });\n\t\t\tcreateEl(\"li\", { text: \"Fri\", parent: heatmapCalendarDaysUl });\n\t\t\tcreateEl(\"li\", { text: \"Sat\", parent: heatmapCalendarDaysUl });\n\t\t\tcreateEl(\"li\", { text: \"Sun\", parent: heatmapCalendarDaysUl });\n\n\t\t\tconst heatmapCalendarBoxesUl = createEl(\"ul\", {\n\t\t\t\tcls: \"heatmap-calendar-boxes\",\n\t\t\t\tparent: heatmapCalendarGraphDiv,\n\t\t\t});\n\n\t\t\tboxes.forEach((e) => {\n\t\t\t\tconst entry = createEl(\"li\", {\n\t\t\t\t\tattr: {\n\t\t\t\t\t\t...(e.backgroundColor && { style: `background-color: ${e.backgroundColor};` }),\n\t\t\t\t\t\t...(e.date && { \"data-date\": e.date }),\n\t\t\t\t\t},\n\t\t\t\t\tcls: e.classNames,\n\t\t\t\t\tparent: heatmapCalendarBoxesUl,\n\t\t\t\t});\n\n\t\t\t\tcreateSpan({\n\t\t\t\t\tcls: \"heatmap-calendar-content\",\n\t\t\t\t\tparent: entry,\n\t\t\t\t\ttext: e.content,\n\t\t\t\t});\n\t\t\t});\n\t\t};\n\t}\n\n\tonunload(): void {}\n\n\tasync loadSettings(): Promise<CalendarSettings> {\n\t\tconst storedSettings: CalendarSettings = await this.loadData();\n\t\tconsole.log(\"stored settings:\", storedSettings);\n\t\tconst settings = Object.assign({}, DEFAULT_SETTINGS, storedSettings);\n\t\tconsole.log(\"settings:\", settings);\n\t\treturn settings;\n\t}\n\n\tasync saveSettings(settings: CalendarSettings): Promise<void> {\n\t\tawait this.saveData(settings);\n\t}\n}\n", "import { CalendarData } from \"model\";\n\nexport const DEFAULT_COLORS = { default: [\"#c6e48b\", \"#7bc96f\", \"#49af5d\", \"#2e8840\", \"#196127\"] };\n\nexport const DEFAULT_SETTINGS: CalendarData = {\n\tyear: new Date().getFullYear(),\n\tcolors: DEFAULT_COLORS,\n\tentries: [],\n\tshowCurrentDayBorder: true,\n\tintensity: {\n\t\tdefault: 4,\n\t\tstartScale: 1,\n\t\tendScale: 5,\n\t},\n};\n", "import HeatmapCalendar from \"main\";\nimport { CalendarSettings } from \"model\";\nimport { App, PluginSettingTab, setIcon } from \"obsidian\";\n\nexport default class HeatmapCalendarSettingsTab extends PluginSettingTab {\n\tplugin: HeatmapCalendar;\n\tsettings: CalendarSettings;\n\n\tconstructor(app: App, plugin: HeatmapCalendar, settings: CalendarSettings) {\n\t\tsuper(app, plugin);\n\t\tthis.plugin = plugin;\n\t\tthis.settings = settings;\n\t}\n\n\tprivate async deleteColorMap(key: keyof typeof this.settings.colors) {\n\t\tdelete this.settings.colors[key];\n\t\tawait this.plugin.saveSettings(this.settings);\n\t\tthis.display();\n\t}\n\n\tprivate displayColorSettings() {\n\t\tconst { containerEl } = this;\n\n\t\tcontainerEl.createEl(\"h3\", { text: \"Colors\" });\n\t\tthis.displayColorHelp(containerEl);\n\n\t\tfor (const [key, colors] of Object.entries(this.settings.colors)) {\n\t\t\tconst colorEntryContainer = containerEl.createDiv({\n\t\t\t\tcls: \"heatmap-calendar-settings-colors__container\",\n\t\t\t});\n\n\t\t\tconst colorDataContainer = colorEntryContainer.createDiv({\n\t\t\t\tcls: \"heatmap-calendar-settings-colors__data-container\",\n\t\t\t});\n\n\t\t\tcolorDataContainer.createEl(\"h4\", { text: key });\n\n\t\t\tconst colorRow = colorDataContainer.createDiv({ cls: \"heatmap-calendar-settings-colors__row\" });\n\n\t\t\tconst colorsContainer = colorRow.createDiv({\n\t\t\t\tcls: \"heatmap-calendar-settings-colors__color-container\",\n\t\t\t});\n\n\t\t\tfor (const color of colors) {\n\t\t\t\tcolorsContainer.createEl(\"div\", {\n\t\t\t\t\tcls: \"heatmap-calendar-settings-colors__color-box\",\n\t\t\t\t\tattr: {\n\t\t\t\t\t\tstyle: `background-color: ${color}`,\n\t\t\t\t\t},\n\t\t\t\t});\n\n\t\t\t\tcolorsContainer.createEl(\"pre\", {\n\t\t\t\t\tcls: \"heatmap-calendar-settings-colors__color-name\",\n\t\t\t\t\ttext: color,\n\t\t\t\t});\n\t\t\t}\n\n\t\t\tif (key !== \"default\") {\n\t\t\t\tconst deleteColorButton = colorEntryContainer.createEl(\"button\", {\n\t\t\t\t\tcls: \"mod-warning heatmap-calendar-settings-colors__delete\",\n\t\t\t\t});\n\n\t\t\t\tsetIcon(deleteColorButton, \"trash\");\n\n\t\t\t\tdeleteColorButton.addEventListener(\"click\", () => this.deleteColorMap(key));\n\t\t\t}\n\t\t}\n\n\t\tthis.displayColorInput(containerEl);\n\t}\n\n\tprivate displayColorInput(parent: HTMLElement) {\n\t\tconst inputContainer = parent.createDiv({\n\t\t\tcls: \"heatmap-calendar-settings-colors__new-color-input-container\",\n\t\t});\n\n\t\tconst colorNameInput = inputContainer.createEl(\"input\", {\n\t\t\tcls: \"heatmap-calendar-settings-colors__new-color-input-name\",\n\t\t\tattr: { placeholder: \"Color name\", type: \"text\" },\n\t\t});\n\n\t\tconst colorValueInput = inputContainer.createEl(\"input\", {\n\t\t\tcls: \"heatmap-calendar-settings-colors__new-color-input-value\",\n\t\t\tattr: { placeholder: \"Colors array\", type: \"text\" },\n\t\t});\n\n\t\tconst addColorButton = inputContainer.createEl(\"button\", {\n\t\t\tcls: \"mod-cta heatmap-calendar-settings-colors__new-color-button\",\n\t\t});\n\n\t\tsetIcon(addColorButton, \"plus\");\n\n\t\taddColorButton.addEventListener(\"click\", async () => {\n\t\t\tconst name = this.validate<string>(\n\t\t\t\tcolorNameInput,\n\t\t\t\t(value) => value ?? undefined,\n\t\t\t\t\"Please input a name for your color\",\n\t\t\t);\n\t\t\tconst colors = this.validate<string[]>(\n\t\t\t\tcolorValueInput,\n\t\t\t\t(value) => this.parseColors(value) ?? undefined,\n\t\t\t\t\"Color is not a valid JSON array of colors\",\n\t\t\t);\n\n\t\t\tif (name !== undefined && colors !== undefined) {\n\t\t\t\tthis.settings.colors[name] = colors;\n\t\t\t\tawait this.plugin.saveSettings(this.settings);\n\t\t\t\tthis.display();\n\t\t\t}\n\t\t});\n\t}\n\n\tprivate displayColorHelp(parent: HTMLElement) {\n\t\tparent.createEl(\"p\", {\n\t\t\ttext: \"Add lists of colors which will be globally available on your heatmaps.\",\n\t\t});\n\t\tparent.createEl(\"p\", {\n\t\t\ttext: \"You can use those colors by referencing their name in your heatmap render settings.\",\n\t\t});\n\t}\n\n\tprivate validate<T>(input: HTMLInputElement, validator: (x: string) => T | undefined, msg: string) {\n\t\tconst value = validator(input.value);\n\t\tif (value !== undefined) {\n\t\t\tinput.classList.add(\"has-error\");\n\t\t\tinput.setCustomValidity(msg);\n\t\t} else {\n\t\t\tinput.setCustomValidity(\"\");\n\t\t}\n\t\tinput.reportValidity();\n\t\treturn value;\n\t}\n\n\tprivate parseColors(value: string): undefined | string[] {\n\t\tconst colorRegex =\n\t\t\t/^(#[0-9a-f]{3,6}|rgba?\\(\\s*\\d+%?\\s*,\\s*\\d+%?\\s*,\\s*\\d+%?\\s*(,\\s*\\d+(\\.\\d+)?%?)?\\s*\\))$/i;\n\t\ttry {\n\t\t\tconst data: string[] = JSON.parse(value);\n\t\t\treturn Array.isArray(data) && data.every((color) => colorRegex.test(color)) ? data : undefined;\n\t\t} catch (e) {\n\t\t\treturn undefined;\n\t\t}\n\t}\n\n\tdisplay(): void {\n\t\tconst { containerEl } = this;\n\t\tcontainerEl.empty();\n\t\tcontainerEl.createEl(\"h2\", { text: \"Heatmap Calendar Settings\" });\n\t\tthis.displayColorSettings();\n\t\tconsole.log(\"settings\", this.settings);\n\t}\n}\n"],
  "mappings": "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",
  "names": ["import_obsidian", "_a"]
}
 diff --git a/build/manifest.json b/build/manifest.json new file mode 100644 index 0000000..07a72ad --- /dev/null +++ b/build/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "heatmap-calendar", + "name": "Heatmap Calendar", + "version": "0.6.0", + "minAppVersion": "0.12.0", + "description": "Activity Year Overview for DataviewJS, Github style – Track Goals, Progress, Habits, Tasks, Exercise, Finances, \"Dont Break the Chain\" etc.", + "author": "Richard Slettevoll", + "authorUrl": "https://richard.sl", + "isDesktopOnly": false +} diff --git a/build/styles.css b/build/styles.css new file mode 100644 index 0000000..9a364f5 --- /dev/null +++ b/build/styles.css @@ -0,0 +1,139 @@ +/* Obsidian/DataviewJS Github inspired calendar by Richard Slettevoll - https://richard.sl/ */ + +.heatmap-calendar-graph > * { + padding: 0px; + margin: 0px; + list-style: none; +} + +.heatmap-calendar-graph { + font-size: 0.65em; + display: grid; + grid-template-columns: auto 1fr; + grid-template-areas: + "year months" + "days boxes"; + font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, + "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol"; + width: 100%; +} + +.heatmap-calendar-months { + display: grid; + grid-template-columns: repeat(12, minmax(0, 1fr)); + grid-area: months; + margin-top: 0.1em; + margin-bottom: 0.3em; + grid-gap: 0.3em; +} + +.heatmap-calendar-days { + grid-area: days; + margin-left: 0.1em; + margin-right: 0.3em; + white-space: nowrap; +} + +.heatmap-calendar-boxes { + grid-auto-flow: column; + grid-template-columns: repeat(53, minmax(0, 1fr)); + grid-area: boxes; +} + +.heatmap-calendar-days, +.heatmap-calendar-boxes { + display: grid; + grid-gap: 0.3em; + grid-template-rows: repeat(7, minmax(0, 1fr)); +} + +.heatmap-calendar-year { + grid-area: year; + font-weight: bold; + font-size: 1.2em; +} + +/* only label three days of the week */ +.heatmap-calendar-days li:nth-child(odd) { + visibility: hidden; +} + +.heatmap-calendar-boxes li { + position: relative; + font-size: 0.75em; + background-color: #ebedf0; +} + +.theme-dark .heatmap-calendar-boxes .isEmpty { + background: #333; +} + +.isEmpty { + width: 1em !important; +} + +.hasData { + width: 1em !important; +} + +.heatmap-calendar-boxes li:not(.task-list-item)::before { + content: unset; +} + +.heatmap-calendar-boxes .internal-link { + text-decoration: none; + position: absolute; + width: 100%; + height: 100%; + text-align: center; +} + +.heatmap-calendar-boxes .today { + border: solid 1px rgb(61, 61, 61); +} + +/* Settings */ + +.heatmap-calendar-settings-colors__color-box { + width: 10px; + height: 10px; + display: inline-block; + margin: 0 5px; +} + +.heatmap-calendar-settings-colors__color-box:first-child { + margin-left: 0; +} + +.heatmap-calendar-settings-colors__color-name { + display: inline-block; +} + +.heatmap-calendar-settings-colors__container { + align-items: center; + border-top: 1px solid var(--background-modifier-border); + display: flex; + justify-content: space-between; + padding: 0.5em 0; +} + +.heatmap-calendar-settings-colors__container h4 { + margin: 0.5em 0; +} + +.heatmap-calendar-settings-colors__new-color-input-container { + display: flex; + justify-content: space-between; +} + +.heatmap-calendar-settings-colors__new-color-input-container input { + margin-right: 1em; +} + +.heatmap-calendar-settings-colors__new-color-input-container input { + margin-right: 1em; +} + +.heatmap-calendar-settings-colors__new-color-input-value { + flex-grow: 1; +} diff --git a/styles.css b/styles.css index 8135fd3..57354ae 100644 --- a/styles.css +++ b/styles.css @@ -70,6 +70,7 @@ position: relative; font-size: 0.75em; background-color: #ebedf0; + margin-inline-start: 0 !important; } .theme-dark .heatmap-calendar-boxes .isEmpty { @@ -168,4 +169,4 @@ /* ---- /* ---- DEV Only /END ---- */ -/* ---- \ No newline at end of file +/* ----