From 1bda2accf4cc897308e454531a4cbe000048666d Mon Sep 17 00:00:00 2001 From: Ellpeck Date: Wed, 19 Oct 2022 16:35:21 +0200 Subject: [PATCH] added the ability to create sub-entries --- src/tracker.ts | 258 ++++++++++++------ .../plugins/simple-time-tracker/main.js | 233 +++++++++++----- test-vault/Cool Project.md | 7 +- 3 files changed, 329 insertions(+), 169 deletions(-) diff --git a/src/tracker.ts b/src/tracker.ts index abc5fd9..f60267b 100644 --- a/src/tracker.ts +++ b/src/tracker.ts @@ -9,23 +9,7 @@ export interface Entry { name: string; startTime: number; endTime: number; -} - -export function startEntry(tracker: Tracker, name: string): void { - if (!name) - name = `Segment ${tracker.entries.length + 1}`; - let entry: Entry = { name: name, startTime: moment().unix(), endTime: null }; - tracker.entries.push(entry); -}; - -export function endEntry(tracker: Tracker): void { - let last = tracker.entries.last(); - last.endTime = moment().unix(); -} - -export function isRunning(tracker: Tracker): boolean { - let last = tracker.entries.last(); - return last != null && !last.endTime; + subEntries: Entry[]; } export async function saveTracker(tracker: Tracker, app: App, section: MarkdownSectionInformation): Promise { @@ -64,17 +48,17 @@ export function displayTracker(tracker: Tracker, element: HTMLElement, getSectio .setTooltip(running ? "End" : "Start") .onClick(async () => { if (running) { - endEntry(tracker); + endRunningEntry(tracker); } else { - startEntry(tracker, name.getValue()); + startNewEntry(tracker, newSegmentNameBox.getValue()); } await saveTracker(tracker, this.app, getSectionInfo()); }); btn.buttonEl.addClass("simple-time-tracker-btn"); - let name = new TextComponent(element) + let newSegmentNameBox = new TextComponent(element) .setPlaceholder("Segment name") .setDisabled(running); - name.inputEl.addClass("simple-time-tracker-txt"); + newSegmentNameBox.inputEl.addClass("simple-time-tracker-txt"); // add timers let timer = element.createDiv({ cls: "simple-time-tracker-timers" }); @@ -95,49 +79,8 @@ export function displayTracker(tracker: Tracker, element: HTMLElement, getSectio createEl("th", { text: "Duration" }), createEl("th")); - for (let entry of tracker.entries) { - let row = table.createEl("tr"); - - let name = row.createEl("td"); - let namePar = name.createEl("span", { text: entry.name }); - let nameBox = new TextComponent(name).setValue(entry.name); - nameBox.inputEl.hidden = true; - - row.createEl("td", { text: formatTimestamp(entry.startTime, settings) }); - row.createEl("td", { text: entry.endTime ? formatTimestamp(entry.endTime, settings) : "" }); - row.createEl("td", { text: entry.endTime ? formatDurationBetween(entry.startTime, entry.endTime) : "" }); - - let entryButtons = row.createEl("td"); - let editButton = new ButtonComponent(entryButtons) - .setClass("clickable-icon") - .setTooltip("Edit") - .setIcon("lucide-pencil") - .onClick(async () => { - if (namePar.hidden) { - namePar.hidden = false; - nameBox.inputEl.hidden = true; - editButton.setIcon("lucide-pencil"); - if (nameBox.getValue()) { - entry.name = nameBox.getValue(); - namePar.setText(entry.name); - await saveTracker(tracker, this.app, getSectionInfo()); - } - } else { - namePar.hidden = true; - nameBox.inputEl.hidden = false; - nameBox.setValue(entry.name); - editButton.setIcon("lucide-check"); - } - }); - new ButtonComponent(entryButtons) - .setClass("clickable-icon") - .setTooltip("Remove") - .setIcon("lucide-trash") - .onClick(async () => { - tracker.entries.remove(entry); - await saveTracker(tracker, this.app, getSectionInfo()); - }); - } + for (let entry of tracker.entries) + addEditableTableRow(tracker, entry, table, newSegmentNameBox, running, getSectionInfo, settings, 0); // add copy buttons let buttons = element.createEl("div", { cls: "simple-time-tracker-bottom" }); @@ -161,33 +104,103 @@ export function displayTracker(tracker: Tracker, element: HTMLElement, getSectio }, 1000); } -function setCountdownValues(tracker: Tracker, current: HTMLElement, total: HTMLElement, currentDiv: HTMLDivElement) { - let currEntry = tracker.entries.last(); - if (currEntry) { - if (!currEntry.endTime) - current.setText(formatDurationBetween(currEntry.startTime, moment().unix())); - total.setText(formatDuration(getTotalDuration(tracker))); +function startSubEntry(entry: Entry, name: string) { + // if this entry is not split yet, we add its time as a sub-entry instead + if (!entry.subEntries) { + entry.subEntries = [{ ...entry, name: `Part 1` }]; + entry.startTime = null; + entry.endTime = null; } - currentDiv.hidden = !currEntry || !!currEntry.endTime; + + if (!name) + name = `Part ${entry.subEntries.length + 1}`; + entry.subEntries.push({ name: name, startTime: moment().unix(), endTime: null, subEntries: null }); } -function getTotalDuration(tracker: Tracker): number { - let totalDuration = 0; - for (let entry of tracker.entries) { - let endTime = entry.endTime ? moment.unix(entry.endTime) : moment(); - totalDuration += endTime.diff(moment.unix(entry.startTime)); +function startNewEntry(tracker: Tracker, name: string): void { + if (!name) + name = `Segment ${tracker.entries.length + 1}`; + let entry: Entry = { name: name, startTime: moment().unix(), endTime: null, subEntries: null }; + tracker.entries.push(entry); +}; + +function endRunningEntry(tracker: Tracker): void { + let entry = getRunningEntry(tracker.entries); + entry.endTime = moment().unix(); +} + +function removeEntry(entries: Entry[], toRemove: Entry): boolean { + if (entries.contains(toRemove)) { + entries.remove(toRemove); + return true; + } else { + for (let entry of entries) { + if (entry.subEntries && removeEntry(entry.subEntries, toRemove)) { + // if we only have one sub entry remaining, we can merge back into our main entry + if (entry.subEntries.length == 1) { + let single = entry.subEntries[0]; + entry.startTime = single.startTime; + entry.endTime = single.endTime; + entry.subEntries = null; + } + return true; + } + } } - return totalDuration; + return false; +} + +function isRunning(tracker: Tracker): boolean { + return !!getRunningEntry(tracker.entries); +} + +function getRunningEntry(entries: Entry[]): Entry { + for (let entry of entries) { + // if this entry has sub entries, check if one of them is running + if (entry.subEntries) { + let running = getRunningEntry(entry.subEntries); + if (running) + return running; + } else { + // if this entry has no sub entries and no end time, it's running + if (!entry.endTime) + return entry; + } + } + return null; +} + +function getDuration(entry: Entry) { + if (entry.subEntries) { + return getTotalDuration(entry.subEntries); + } else { + let endTime = entry.endTime ? moment.unix(entry.endTime) : moment(); + return endTime.diff(moment.unix(entry.startTime)); + } +} + +function getTotalDuration(entries: Entry[]): number { + let ret = 0; + for (let entry of entries) + ret += getDuration(entry); + return ret; +} + +function setCountdownValues(tracker: Tracker, current: HTMLElement, total: HTMLElement, currentDiv: HTMLDivElement) { + let running = getRunningEntry(tracker.entries); + if (running && !running.endTime) { + current.setText(formatDuration(getDuration(running))); + currentDiv.hidden = false; + } else { + currentDiv.hidden = true; + } + total.setText(formatDuration(getTotalDuration(tracker.entries))); } function formatTimestamp(timestamp: number, settings: SimpleTimeTrackerSettings): string { return moment.unix(timestamp).format(settings.timestampFormat); } -function formatDurationBetween(startTime: number, endTime: number): string { - return formatDuration(moment.unix(endTime).diff(moment.unix(startTime))); -} - function formatDuration(totalTime: number): string { let duration = moment.duration(totalTime); let ret = ""; @@ -202,8 +215,8 @@ function formatDuration(totalTime: number): string { function createMarkdownTable(tracker: Tracker, settings: SimpleTimeTrackerSettings): string { let table = [["Segment", "Start time", "End time", "Duration"]]; for (let entry of tracker.entries) - table.push(createTableRow(entry, settings)); - table.push(["**Total**", "", "", `**${formatDuration(getTotalDuration(tracker))}**`]); + table.push(...createTableSection(entry, settings)); + table.push(["**Total**", "", "", `**${formatDuration(getTotalDuration(tracker.entries))}**`]); let ret = ""; // calculate the width every column needs to look neat when monospaced @@ -223,15 +236,82 @@ function createMarkdownTable(tracker: Tracker, settings: SimpleTimeTrackerSettin function createCsv(tracker: Tracker, settings: SimpleTimeTrackerSettings): string { let ret = ""; - for (let entry of tracker.entries) - ret += createTableRow(entry, settings).join(settings.csvDelimiter) + "\n"; + for (let entry of tracker.entries) { + for (let row of createTableSection(entry, settings)) + ret += row.join(settings.csvDelimiter) + "\n"; + } return ret; } -function createTableRow(entry: Entry, settings: SimpleTimeTrackerSettings): string[] { - return [ +function createTableSection(entry: Entry, settings: SimpleTimeTrackerSettings): string[][] { + let ret: string[][] = [[ entry.name, - formatTimestamp(entry.startTime, settings), + entry.startTime ? formatTimestamp(entry.startTime, settings) : "", entry.endTime ? formatTimestamp(entry.endTime, settings) : "", - entry.endTime ? formatDurationBetween(entry.startTime, entry.endTime) : ""]; + entry.endTime || entry.subEntries ? formatDuration(getDuration(entry)) : ""]]; + if (entry.subEntries) { + for (let sub of entry.subEntries) + ret.push(...createTableSection(sub, settings)); + } + return ret; +} + +function addEditableTableRow(tracker: Tracker, entry: Entry, table: HTMLTableElement, newSegmentNameBox: TextComponent, running: boolean, getSectionInfo: () => MarkdownSectionInformation, settings: SimpleTimeTrackerSettings, indent: number) { + let row = table.createEl("tr"); + + let name = row.createEl("td"); + let namePar = name.createEl("span", { text: entry.name }); + namePar.style.marginLeft = `${indent}em`; + let nameBox = new TextComponent(name).setValue(entry.name); + nameBox.inputEl.hidden = true; + + row.createEl("td", { text: entry.startTime ? formatTimestamp(entry.startTime, settings) : "" }); + row.createEl("td", { text: entry.endTime ? formatTimestamp(entry.endTime, settings) : "" }); + row.createEl("td", { text: entry.endTime || entry.subEntries ? formatDuration(getDuration(entry)) : "" }); + + let entryButtons = row.createEl("td"); + if (!running) { + new ButtonComponent(entryButtons) + .setClass("clickable-icon") + .setIcon(`lucide-play`) + .setTooltip("Continue") + .onClick(async () => { + startSubEntry(entry, newSegmentNameBox.getValue()); + await saveTracker(tracker, this.app, getSectionInfo()); + }); + } + let editButton = new ButtonComponent(entryButtons) + .setClass("clickable-icon") + .setTooltip("Edit") + .setIcon("lucide-pencil") + .onClick(async () => { + if (namePar.hidden) { + namePar.hidden = false; + nameBox.inputEl.hidden = true; + editButton.setIcon("lucide-pencil"); + if (nameBox.getValue()) { + entry.name = nameBox.getValue(); + namePar.setText(entry.name); + await saveTracker(tracker, this.app, getSectionInfo()); + } + } else { + namePar.hidden = true; + nameBox.inputEl.hidden = false; + nameBox.setValue(entry.name); + editButton.setIcon("lucide-check"); + } + }); + new ButtonComponent(entryButtons) + .setClass("clickable-icon") + .setTooltip("Remove") + .setIcon("lucide-trash") + .onClick(async () => { + removeEntry(tracker.entries, entry); + await saveTracker(tracker, this.app, getSectionInfo()); + }); + + if (entry.subEntries) { + for (let sub of entry.subEntries) + addEditableTableRow(tracker, sub, table, newSegmentNameBox, running, getSectionInfo, settings, indent + 1); + } } diff --git a/test-vault/.obsidian/plugins/simple-time-tracker/main.js b/test-vault/.obsidian/plugins/simple-time-tracker/main.js index ed62bdf..bcc4e94 100644 --- a/test-vault/.obsidian/plugins/simple-time-tracker/main.js +++ b/test-vault/.obsidian/plugins/simple-time-tracker/main.js @@ -4,10 +4,27 @@ if you want to view the source, please visit the github repository of this plugi */ var __create = Object.create; var __defProp = Object.defineProperty; +var __defProps = Object.defineProperties; var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropDescs = Object.getOwnPropertyDescriptors; var __getOwnPropNames = Object.getOwnPropertyNames; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; var __getProtoOf = Object.getPrototypeOf; 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 __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); var __markAsModule = (target) => __defProp(target, "__esModule", { value: true }); var __export = (target, all) => { __markAsModule(target); @@ -94,20 +111,6 @@ var SimpleTimeTrackerSettingsTab = class extends import_obsidian.PluginSettingTa // src/tracker.ts var import_obsidian2 = __toModule(require("obsidian")); -function startEntry(tracker, name) { - if (!name) - name = `Segment ${tracker.entries.length + 1}`; - let entry = { name, startTime: (0, import_obsidian2.moment)().unix(), endTime: null }; - tracker.entries.push(entry); -} -function endEntry(tracker) { - let last = tracker.entries.last(); - last.endTime = (0, import_obsidian2.moment)().unix(); -} -function isRunning(tracker) { - let last = tracker.entries.last(); - return last != null && !last.endTime; -} function saveTracker(tracker, app, section) { return __async(this, null, function* () { let file = app.workspace.getActiveFile(); @@ -137,15 +140,15 @@ function displayTracker(tracker, element, getSectionInfo, settings) { let running = isRunning(tracker); let btn = new import_obsidian2.ButtonComponent(element).setClass("clickable-icon").setIcon(`lucide-${running ? "stop" : "play"}-circle`).setTooltip(running ? "End" : "Start").onClick(() => __async(this, null, function* () { if (running) { - endEntry(tracker); + endRunningEntry(tracker); } else { - startEntry(tracker, name.getValue()); + startNewEntry(tracker, newSegmentNameBox.getValue()); } yield saveTracker(tracker, this.app, getSectionInfo()); })); btn.buttonEl.addClass("simple-time-tracker-btn"); - let name = new import_obsidian2.TextComponent(element).setPlaceholder("Segment name").setDisabled(running); - name.inputEl.addClass("simple-time-tracker-txt"); + let newSegmentNameBox = new import_obsidian2.TextComponent(element).setPlaceholder("Segment name").setDisabled(running); + newSegmentNameBox.inputEl.addClass("simple-time-tracker-txt"); let timer = element.createDiv({ cls: "simple-time-tracker-timers" }); let currentDiv = timer.createEl("div", { cls: "simple-time-tracker-timer" }); let current = currentDiv.createEl("span", { cls: "simple-time-tracker-timer-time" }); @@ -156,38 +159,8 @@ function displayTracker(tracker, element, getSectionInfo, settings) { if (tracker.entries.length > 0) { let table = element.createEl("table", { cls: "simple-time-tracker-table" }); table.createEl("tr").append(createEl("th", { text: "Segment" }), createEl("th", { text: "Start time" }), createEl("th", { text: "End time" }), createEl("th", { text: "Duration" }), createEl("th")); - for (let entry of tracker.entries) { - let row = table.createEl("tr"); - let name2 = row.createEl("td"); - let namePar = name2.createEl("span", { text: entry.name }); - let nameBox = new import_obsidian2.TextComponent(name2).setValue(entry.name); - nameBox.inputEl.hidden = true; - row.createEl("td", { text: formatTimestamp(entry.startTime, settings) }); - row.createEl("td", { text: entry.endTime ? formatTimestamp(entry.endTime, settings) : "" }); - row.createEl("td", { text: entry.endTime ? formatDurationBetween(entry.startTime, entry.endTime) : "" }); - let entryButtons = row.createEl("td"); - let editButton = new import_obsidian2.ButtonComponent(entryButtons).setClass("clickable-icon").setTooltip("Edit").setIcon("lucide-pencil").onClick(() => __async(this, null, function* () { - if (namePar.hidden) { - namePar.hidden = false; - nameBox.inputEl.hidden = true; - editButton.setIcon("lucide-pencil"); - if (nameBox.getValue()) { - entry.name = nameBox.getValue(); - namePar.setText(entry.name); - yield saveTracker(tracker, this.app, getSectionInfo()); - } - } else { - namePar.hidden = true; - nameBox.inputEl.hidden = false; - nameBox.setValue(entry.name); - editButton.setIcon("lucide-check"); - } - })); - new import_obsidian2.ButtonComponent(entryButtons).setClass("clickable-icon").setTooltip("Remove").setIcon("lucide-trash").onClick(() => __async(this, null, function* () { - tracker.entries.remove(entry); - yield saveTracker(tracker, this.app, getSectionInfo()); - })); - } + for (let entry of tracker.entries) + addEditableTableRow(tracker, entry, table, newSegmentNameBox, running, getSectionInfo, settings, 0); let buttons = element.createEl("div", { cls: "simple-time-tracker-bottom" }); new import_obsidian2.ButtonComponent(buttons).setButtonText("Copy as table").onClick(() => navigator.clipboard.writeText(createMarkdownTable(tracker, settings))); new import_obsidian2.ButtonComponent(buttons).setButtonText("Copy as CSV").onClick(() => navigator.clipboard.writeText(createCsv(tracker, settings))); @@ -201,29 +174,88 @@ function displayTracker(tracker, element, getSectionInfo, settings) { setCountdownValues(tracker, current, total, currentDiv); }, 1e3); } -function setCountdownValues(tracker, current, total, currentDiv) { - let currEntry = tracker.entries.last(); - if (currEntry) { - if (!currEntry.endTime) - current.setText(formatDurationBetween(currEntry.startTime, (0, import_obsidian2.moment)().unix())); - total.setText(formatDuration(getTotalDuration(tracker))); +function startSubEntry(entry, name) { + if (!entry.subEntries) { + entry.subEntries = [__spreadProps(__spreadValues({}, entry), { name: `Part 1` })]; + entry.startTime = null; + entry.endTime = null; } - currentDiv.hidden = !currEntry || !!currEntry.endTime; + if (!name) + name = `Part ${entry.subEntries.length + 1}`; + entry.subEntries.push({ name, startTime: (0, import_obsidian2.moment)().unix(), endTime: null, subEntries: null }); } -function getTotalDuration(tracker) { - let totalDuration = 0; - for (let entry of tracker.entries) { - let endTime = entry.endTime ? import_obsidian2.moment.unix(entry.endTime) : (0, import_obsidian2.moment)(); - totalDuration += endTime.diff(import_obsidian2.moment.unix(entry.startTime)); +function startNewEntry(tracker, name) { + if (!name) + name = `Segment ${tracker.entries.length + 1}`; + let entry = { name, startTime: (0, import_obsidian2.moment)().unix(), endTime: null, subEntries: null }; + tracker.entries.push(entry); +} +function endRunningEntry(tracker) { + let entry = getRunningEntry(tracker.entries); + entry.endTime = (0, import_obsidian2.moment)().unix(); +} +function removeEntry(entries, toRemove) { + if (entries.contains(toRemove)) { + entries.remove(toRemove); + return true; + } else { + for (let entry of entries) { + if (entry.subEntries && removeEntry(entry.subEntries, toRemove)) { + if (entry.subEntries.length == 1) { + let single = entry.subEntries[0]; + entry.startTime = single.startTime; + entry.endTime = single.endTime; + entry.subEntries = null; + } + return true; + } + } } - return totalDuration; + return false; +} +function isRunning(tracker) { + return !!getRunningEntry(tracker.entries); +} +function getRunningEntry(entries) { + for (let entry of entries) { + if (entry.subEntries) { + let running = getRunningEntry(entry.subEntries); + if (running) + return running; + } else { + if (!entry.endTime) + return entry; + } + } + return null; +} +function getDuration(entry) { + if (entry.subEntries) { + return getTotalDuration(entry.subEntries); + } else { + let endTime = entry.endTime ? import_obsidian2.moment.unix(entry.endTime) : (0, import_obsidian2.moment)(); + return endTime.diff(import_obsidian2.moment.unix(entry.startTime)); + } +} +function getTotalDuration(entries) { + let ret = 0; + for (let entry of entries) + ret += getDuration(entry); + return ret; +} +function setCountdownValues(tracker, current, total, currentDiv) { + let running = getRunningEntry(tracker.entries); + if (running && !running.endTime) { + current.setText(formatDuration(getDuration(running))); + currentDiv.hidden = false; + } else { + currentDiv.hidden = true; + } + total.setText(formatDuration(getTotalDuration(tracker.entries))); } function formatTimestamp(timestamp, settings) { return import_obsidian2.moment.unix(timestamp).format(settings.timestampFormat); } -function formatDurationBetween(startTime, endTime) { - return formatDuration(import_obsidian2.moment.unix(endTime).diff(import_obsidian2.moment.unix(startTime))); -} function formatDuration(totalTime) { let duration = import_obsidian2.moment.duration(totalTime); let ret = ""; @@ -237,8 +269,8 @@ function formatDuration(totalTime) { function createMarkdownTable(tracker, settings) { let table = [["Segment", "Start time", "End time", "Duration"]]; for (let entry of tracker.entries) - table.push(createTableRow(entry, settings)); - table.push(["**Total**", "", "", `**${formatDuration(getTotalDuration(tracker))}**`]); + table.push(...createTableSection(entry, settings)); + table.push(["**Total**", "", "", `**${formatDuration(getTotalDuration(tracker.entries))}**`]); let ret = ""; let widths = Array.from(Array(4).keys()).map((i) => Math.max(...table.map((a) => a[i].length))); for (let r = 0; r < table.length; r++) { @@ -253,17 +285,67 @@ function createMarkdownTable(tracker, settings) { } function createCsv(tracker, settings) { let ret = ""; - for (let entry of tracker.entries) - ret += createTableRow(entry, settings).join(settings.csvDelimiter) + "\n"; + for (let entry of tracker.entries) { + for (let row of createTableSection(entry, settings)) + ret += row.join(settings.csvDelimiter) + "\n"; + } return ret; } -function createTableRow(entry, settings) { - return [ +function createTableSection(entry, settings) { + let ret = [[ entry.name, - formatTimestamp(entry.startTime, settings), + entry.startTime ? formatTimestamp(entry.startTime, settings) : "", entry.endTime ? formatTimestamp(entry.endTime, settings) : "", - entry.endTime ? formatDurationBetween(entry.startTime, entry.endTime) : "" - ]; + entry.endTime || entry.subEntries ? formatDuration(getDuration(entry)) : "" + ]]; + if (entry.subEntries) { + for (let sub of entry.subEntries) + ret.push(...createTableSection(sub, settings)); + } + return ret; +} +function addEditableTableRow(tracker, entry, table, newSegmentNameBox, running, getSectionInfo, settings, indent) { + let row = table.createEl("tr"); + let name = row.createEl("td"); + let namePar = name.createEl("span", { text: entry.name }); + namePar.style.marginLeft = `${indent}em`; + let nameBox = new import_obsidian2.TextComponent(name).setValue(entry.name); + nameBox.inputEl.hidden = true; + row.createEl("td", { text: entry.startTime ? formatTimestamp(entry.startTime, settings) : "" }); + row.createEl("td", { text: entry.endTime ? formatTimestamp(entry.endTime, settings) : "" }); + row.createEl("td", { text: entry.endTime || entry.subEntries ? formatDuration(getDuration(entry)) : "" }); + let entryButtons = row.createEl("td"); + if (!running) { + new import_obsidian2.ButtonComponent(entryButtons).setClass("clickable-icon").setIcon(`lucide-play`).setTooltip("Continue").onClick(() => __async(this, null, function* () { + startSubEntry(entry, newSegmentNameBox.getValue()); + yield saveTracker(tracker, this.app, getSectionInfo()); + })); + } + let editButton = new import_obsidian2.ButtonComponent(entryButtons).setClass("clickable-icon").setTooltip("Edit").setIcon("lucide-pencil").onClick(() => __async(this, null, function* () { + if (namePar.hidden) { + namePar.hidden = false; + nameBox.inputEl.hidden = true; + editButton.setIcon("lucide-pencil"); + if (nameBox.getValue()) { + entry.name = nameBox.getValue(); + namePar.setText(entry.name); + yield saveTracker(tracker, this.app, getSectionInfo()); + } + } else { + namePar.hidden = true; + nameBox.inputEl.hidden = false; + nameBox.setValue(entry.name); + editButton.setIcon("lucide-check"); + } + })); + new import_obsidian2.ButtonComponent(entryButtons).setClass("clickable-icon").setTooltip("Remove").setIcon("lucide-trash").onClick(() => __async(this, null, function* () { + removeEntry(tracker.entries, entry); + yield saveTracker(tracker, this.app, getSectionInfo()); + })); + if (entry.subEntries) { + for (let sub of entry.subEntries) + addEditableTableRow(tracker, sub, table, newSegmentNameBox, running, getSectionInfo, settings, indent + 1); + } } // src/main.ts @@ -297,3 +379,4 @@ var SimpleTimeTrackerPlugin = class extends import_obsidian3.Plugin { }); } }; +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/main.ts", "src/settings.ts", "src/settings-tab.ts", "src/tracker.ts"],
  "sourcesContent": ["import { Plugin } from \"obsidian\";\r\nimport { defaultSettings, SimpleTimeTrackerSettings } from \"./settings\";\r\nimport { SimpleTimeTrackerSettingsTab } from \"./settings-tab\";\r\nimport { displayTracker, loadTracker } from \"./tracker\";\r\n\r\nexport default class SimpleTimeTrackerPlugin extends Plugin {\r\n\r\n\tsettings: SimpleTimeTrackerSettings;\r\n\r\n\tasync onload(): Promise<void> {\r\n\t\tawait this.loadSettings();\r\n\r\n\t\tthis.addSettingTab(new SimpleTimeTrackerSettingsTab(this.app, this));\r\n\r\n\t\tthis.registerMarkdownCodeBlockProcessor(\"simple-time-tracker\", (s, e, i) => {\r\n\t\t\tlet tracker = loadTracker(s);\r\n\t\t\te.empty();\r\n\t\t\tdisplayTracker(tracker, e, () => i.getSectionInfo(e), this.settings);\r\n\t\t});\r\n\r\n\t\tthis.addCommand({\r\n\t\t\tid: `insert`,\r\n\t\t\tname: `Insert Time Tracker`,\r\n\t\t\teditorCallback: (e, _) => {\r\n\t\t\t\te.replaceSelection(\"```simple-time-tracker\\n```\\n\");\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\tasync loadSettings() {\r\n\t\tthis.settings = Object.assign({}, defaultSettings, await this.loadData());\r\n\t}\r\n\r\n\tasync saveSettings() {\r\n\t\tawait this.saveData(this.settings);\r\n\t}\r\n}\r\n", "export const defaultSettings: SimpleTimeTrackerSettings = {\r\n    timestampFormat: \"YY-MM-DD hh:mm:ss\",\r\n    csvDelimiter: \",\"\r\n};\r\n\r\nexport interface SimpleTimeTrackerSettings {\r\n\r\n    timestampFormat: string;\r\n    csvDelimiter: string;\r\n\r\n}\r\n", "import { App, PluginSettingTab, Setting } from \"obsidian\";\r\nimport SimpleTimeTrackerPlugin from \"./main\";\r\nimport { defaultSettings } from \"./settings\";\r\n\r\nexport class SimpleTimeTrackerSettingsTab extends PluginSettingTab {\r\n\r\n    plugin: SimpleTimeTrackerPlugin;\r\n\r\n    constructor(app: App, plugin: SimpleTimeTrackerPlugin) {\r\n        super(app, plugin);\r\n        this.plugin = plugin;\r\n    }\r\n\r\n    display(): void {\r\n        this.containerEl.empty();\r\n        this.containerEl.createEl(\"h2\", { text: \"Super Simple Time Tracker Settings\" });\r\n\r\n        new Setting(this.containerEl)\r\n            .setName(\"Timestamp Display Format\")\r\n            .setDesc(createFragment(f => {\r\n                f.createSpan({ text: \"The way that timestamps in time tracker tables should be displayed. Uses \" });\r\n                f.createEl(\"a\", { text: \"moment.js\", href: \"https://momentjs.com/docs/#/parsing/string-format/\" });\r\n                f.createSpan({ text: \" syntax.\" });\r\n            }))\r\n            .addText(t => {\r\n                t.setValue(String(this.plugin.settings.timestampFormat));\r\n                t.onChange(async v => {\r\n                    this.plugin.settings.timestampFormat = v.length ? v : defaultSettings.timestampFormat;\r\n                    await this.plugin.saveSettings();\r\n                });\r\n            });\r\n\r\n        new Setting(this.containerEl)\r\n            .setName(\"CSV Delimiter\")\r\n            .setDesc(\"The delimiter character that should be used when copying a tracker table as CSV. For example, some languages use a semicolon instead of a comma.\")\r\n            .addText(t => {\r\n                t.setValue(String(this.plugin.settings.csvDelimiter));\r\n                t.onChange(async v => {\r\n                    this.plugin.settings.csvDelimiter = v.length ? v : defaultSettings.csvDelimiter;\r\n                    await this.plugin.saveSettings();\r\n                });\r\n            });\r\n\r\n        this.containerEl.createEl(\"hr\");\r\n        this.containerEl.createEl(\"p\", { text: \"If you like this plugin and want to support its development, you can do so through my website by clicking this fancy image!\" });\r\n        this.containerEl.createEl(\"a\", { href: \"https://ellpeck.de/support\" })\r\n            .createEl(\"img\", { attr: { src: \"https://ellpeck.de/res/generalsupport.png\" }, cls: \"simple-time-tracker-support\" });\r\n    }\r\n}\r\n", "import { moment, App, MarkdownSectionInformation, ButtonComponent, TextComponent } from \"obsidian\";\r\nimport { SimpleTimeTrackerSettings } from \"./settings\";\r\n\r\nexport interface Tracker {\r\n    entries: Entry[];\r\n}\r\n\r\nexport interface Entry {\r\n    name: string;\r\n    startTime: number;\r\n    endTime: number;\r\n    subEntries: Entry[];\r\n}\r\n\r\nexport async function saveTracker(tracker: Tracker, app: App, section: MarkdownSectionInformation): Promise<void> {\r\n    let file = app.workspace.getActiveFile();\r\n    if (!file)\r\n        return;\r\n    let content = await app.vault.read(file);\r\n\r\n    // figure out what part of the content we have to edit\r\n    let lines = content.split(\"\\n\");\r\n    let prev = lines.filter((_, i) => i <= section.lineStart).join(\"\\n\");\r\n    let next = lines.filter((_, i) => i >= section.lineEnd).join(\"\\n\");\r\n    // edit only the code block content, leave the rest untouched\r\n    content = `${prev}\\n${JSON.stringify(tracker)}\\n${next}`;\r\n\r\n    await app.vault.modify(file, content);\r\n}\r\n\r\nexport function loadTracker(json: string): Tracker {\r\n    if (json) {\r\n        try {\r\n            return JSON.parse(json);\r\n        } catch (e) {\r\n            console.log(`Failed to parse Tracker from ${json}`);\r\n        }\r\n    }\r\n    return { entries: [] };\r\n}\r\n\r\nexport function displayTracker(tracker: Tracker, element: HTMLElement, getSectionInfo: () => MarkdownSectionInformation, settings: SimpleTimeTrackerSettings): void {\r\n    // add start/stop controls\r\n    let running = isRunning(tracker);\r\n    let btn = new ButtonComponent(element)\r\n        .setClass(\"clickable-icon\")\r\n        .setIcon(`lucide-${running ? \"stop\" : \"play\"}-circle`)\r\n        .setTooltip(running ? \"End\" : \"Start\")\r\n        .onClick(async () => {\r\n            if (running) {\r\n                endRunningEntry(tracker);\r\n            } else {\r\n                startNewEntry(tracker, newSegmentNameBox.getValue());\r\n            }\r\n            await saveTracker(tracker, this.app, getSectionInfo());\r\n        });\r\n    btn.buttonEl.addClass(\"simple-time-tracker-btn\");\r\n    let newSegmentNameBox = new TextComponent(element)\r\n        .setPlaceholder(\"Segment name\")\r\n        .setDisabled(running);\r\n    newSegmentNameBox.inputEl.addClass(\"simple-time-tracker-txt\");\r\n\r\n    // add timers\r\n    let timer = element.createDiv({ cls: \"simple-time-tracker-timers\" });\r\n    let currentDiv = timer.createEl(\"div\", { cls: \"simple-time-tracker-timer\" });\r\n    let current = currentDiv.createEl(\"span\", { cls: \"simple-time-tracker-timer-time\" });\r\n    currentDiv.createEl(\"span\", { text: \"Current\" });\r\n    let totalDiv = timer.createEl(\"div\", { cls: \"simple-time-tracker-timer\" });\r\n    let total = totalDiv.createEl(\"span\", { cls: \"simple-time-tracker-timer-time\", text: \"0s\" });\r\n    totalDiv.createEl(\"span\", { text: \"Total\" });\r\n\r\n    if (tracker.entries.length > 0) {\r\n        // add table\r\n        let table = element.createEl(\"table\", { cls: \"simple-time-tracker-table\" });\r\n        table.createEl(\"tr\").append(\r\n            createEl(\"th\", { text: \"Segment\" }),\r\n            createEl(\"th\", { text: \"Start time\" }),\r\n            createEl(\"th\", { text: \"End time\" }),\r\n            createEl(\"th\", { text: \"Duration\" }),\r\n            createEl(\"th\"));\r\n\r\n        for (let entry of tracker.entries)\r\n            addEditableTableRow(tracker, entry, table, newSegmentNameBox, running, getSectionInfo, settings, 0);\r\n\r\n        // add copy buttons\r\n        let buttons = element.createEl(\"div\", { cls: \"simple-time-tracker-bottom\" });\r\n        new ButtonComponent(buttons)\r\n            .setButtonText(\"Copy as table\")\r\n            .onClick(() => navigator.clipboard.writeText(createMarkdownTable(tracker, settings)));\r\n        new ButtonComponent(buttons)\r\n            .setButtonText(\"Copy as CSV\")\r\n            .onClick(() => navigator.clipboard.writeText(createCsv(tracker, settings)));\r\n    }\r\n\r\n\r\n    setCountdownValues(tracker, current, total, currentDiv);\r\n    let intervalId = window.setInterval(() => {\r\n        // we delete the interval timer when the element is removed\r\n        if (!element.isConnected) {\r\n            window.clearInterval(intervalId);\r\n            return;\r\n        }\r\n        setCountdownValues(tracker, current, total, currentDiv);\r\n    }, 1000);\r\n}\r\n\r\nfunction startSubEntry(entry: Entry, name: string) {\r\n    // if this entry is not split yet, we add its time as a sub-entry instead\r\n    if (!entry.subEntries) {\r\n        entry.subEntries = [{ ...entry, name: `Part 1` }];\r\n        entry.startTime = null;\r\n        entry.endTime = null;\r\n    }\r\n\r\n    if (!name)\r\n        name = `Part ${entry.subEntries.length + 1}`;\r\n    entry.subEntries.push({ name: name, startTime: moment().unix(), endTime: null, subEntries: null });\r\n}\r\n\r\nfunction startNewEntry(tracker: Tracker, name: string): void {\r\n    if (!name)\r\n        name = `Segment ${tracker.entries.length + 1}`;\r\n    let entry: Entry = { name: name, startTime: moment().unix(), endTime: null, subEntries: null };\r\n    tracker.entries.push(entry);\r\n};\r\n\r\nfunction endRunningEntry(tracker: Tracker): void {\r\n    let entry = getRunningEntry(tracker.entries);\r\n    entry.endTime = moment().unix();\r\n}\r\n\r\nfunction removeEntry(entries: Entry[], toRemove: Entry): boolean {\r\n    if (entries.contains(toRemove)) {\r\n        entries.remove(toRemove);\r\n        return true;\r\n    } else {\r\n        for (let entry of entries) {\r\n            if (entry.subEntries && removeEntry(entry.subEntries, toRemove)) {\r\n                // if we only have one sub entry remaining, we can merge back into our main entry\r\n                if (entry.subEntries.length == 1) {\r\n                    let single = entry.subEntries[0];\r\n                    entry.startTime = single.startTime;\r\n                    entry.endTime = single.endTime;\r\n                    entry.subEntries = null;\r\n                }\r\n                return true;\r\n            }\r\n        }\r\n    }\r\n    return false;\r\n}\r\n\r\nfunction isRunning(tracker: Tracker): boolean {\r\n    return !!getRunningEntry(tracker.entries);\r\n}\r\n\r\nfunction getRunningEntry(entries: Entry[]): Entry {\r\n    for (let entry of entries) {\r\n        // if this entry has sub entries, check if one of them is running\r\n        if (entry.subEntries) {\r\n            let running = getRunningEntry(entry.subEntries);\r\n            if (running)\r\n                return running;\r\n        } else {\r\n            // if this entry has no sub entries and no end time, it's running\r\n            if (!entry.endTime)\r\n                return entry;\r\n        }\r\n    }\r\n    return null;\r\n}\r\n\r\nfunction getDuration(entry: Entry) {\r\n    if (entry.subEntries) {\r\n        return getTotalDuration(entry.subEntries);\r\n    } else {\r\n        let endTime = entry.endTime ? moment.unix(entry.endTime) : moment();\r\n        return endTime.diff(moment.unix(entry.startTime));\r\n    }\r\n}\r\n\r\nfunction getTotalDuration(entries: Entry[]): number {\r\n    let ret = 0;\r\n    for (let entry of entries)\r\n        ret += getDuration(entry);\r\n    return ret;\r\n}\r\n\r\nfunction setCountdownValues(tracker: Tracker, current: HTMLElement, total: HTMLElement, currentDiv: HTMLDivElement) {\r\n    let running = getRunningEntry(tracker.entries);\r\n    if (running && !running.endTime) {\r\n        current.setText(formatDuration(getDuration(running)));\r\n        currentDiv.hidden = false;\r\n    } else {\r\n        currentDiv.hidden = true;\r\n    }\r\n    total.setText(formatDuration(getTotalDuration(tracker.entries)));\r\n}\r\n\r\nfunction formatTimestamp(timestamp: number, settings: SimpleTimeTrackerSettings): string {\r\n    return moment.unix(timestamp).format(settings.timestampFormat);\r\n}\r\n\r\nfunction formatDuration(totalTime: number): string {\r\n    let duration = moment.duration(totalTime);\r\n    let ret = \"\";\r\n    if (duration.hours() > 0)\r\n        ret += duration.hours() + \"h \";\r\n    if (duration.minutes() > 0)\r\n        ret += duration.minutes() + \"m \";\r\n    ret += duration.seconds() + \"s\";\r\n    return ret;\r\n}\r\n\r\nfunction createMarkdownTable(tracker: Tracker, settings: SimpleTimeTrackerSettings): string {\r\n    let table = [[\"Segment\", \"Start time\", \"End time\", \"Duration\"]];\r\n    for (let entry of tracker.entries)\r\n        table.push(...createTableSection(entry, settings));\r\n    table.push([\"**Total**\", \"\", \"\", `**${formatDuration(getTotalDuration(tracker.entries))}**`]);\r\n\r\n    let ret = \"\";\r\n    // calculate the width every column needs to look neat when monospaced\r\n    let widths = Array.from(Array(4).keys()).map(i => Math.max(...table.map(a => a[i].length)));\r\n    for (let r = 0; r < table.length; r++) {\r\n        // add separators after first row\r\n        if (r == 1)\r\n            ret += Array.from(Array(4).keys()).map(i => \"-\".repeat(widths[i])).join(\" | \") + \"\\n\";\r\n\r\n        let row: string[] = [];\r\n        for (let i = 0; i < 4; i++)\r\n            row.push(table[r][i].padEnd(widths[i], \" \"));\r\n        ret += row.join(\" | \") + \"\\n\";\r\n    }\r\n    return ret;\r\n}\r\n\r\nfunction createCsv(tracker: Tracker, settings: SimpleTimeTrackerSettings): string {\r\n    let ret = \"\";\r\n    for (let entry of tracker.entries) {\r\n        for (let row of createTableSection(entry, settings))\r\n            ret += row.join(settings.csvDelimiter) + \"\\n\";\r\n    }\r\n    return ret;\r\n}\r\n\r\nfunction createTableSection(entry: Entry, settings: SimpleTimeTrackerSettings): string[][] {\r\n    let ret: string[][] = [[\r\n        entry.name,\r\n        entry.startTime ? formatTimestamp(entry.startTime, settings) : \"\",\r\n        entry.endTime ? formatTimestamp(entry.endTime, settings) : \"\",\r\n        entry.endTime || entry.subEntries ? formatDuration(getDuration(entry)) : \"\"]];\r\n    if (entry.subEntries) {\r\n        for (let sub of entry.subEntries)\r\n            ret.push(...createTableSection(sub, settings));\r\n    }\r\n    return ret;\r\n}\r\n\r\nfunction addEditableTableRow(tracker: Tracker, entry: Entry, table: HTMLTableElement, newSegmentNameBox: TextComponent, running: boolean, getSectionInfo: () => MarkdownSectionInformation, settings: SimpleTimeTrackerSettings, indent: number) {\r\n    let row = table.createEl(\"tr\");\r\n\r\n    let name = row.createEl(\"td\");\r\n    let namePar = name.createEl(\"span\", { text: entry.name });\r\n    namePar.style.marginLeft = `${indent}em`;\r\n    let nameBox = new TextComponent(name).setValue(entry.name);\r\n    nameBox.inputEl.hidden = true;\r\n\r\n    row.createEl(\"td\", { text: entry.startTime ? formatTimestamp(entry.startTime, settings) : \"\" });\r\n    row.createEl(\"td\", { text: entry.endTime ? formatTimestamp(entry.endTime, settings) : \"\" });\r\n    row.createEl(\"td\", { text: entry.endTime || entry.subEntries ? formatDuration(getDuration(entry)) : \"\" });\r\n\r\n    let entryButtons = row.createEl(\"td\");\r\n    if (!running) {\r\n        new ButtonComponent(entryButtons)\r\n            .setClass(\"clickable-icon\")\r\n            .setIcon(`lucide-play`)\r\n            .setTooltip(\"Continue\")\r\n            .onClick(async () => {\r\n                startSubEntry(entry, newSegmentNameBox.getValue());\r\n                await saveTracker(tracker, this.app, getSectionInfo());\r\n            });\r\n    }\r\n    let editButton = new ButtonComponent(entryButtons)\r\n        .setClass(\"clickable-icon\")\r\n        .setTooltip(\"Edit\")\r\n        .setIcon(\"lucide-pencil\")\r\n        .onClick(async () => {\r\n            if (namePar.hidden) {\r\n                namePar.hidden = false;\r\n                nameBox.inputEl.hidden = true;\r\n                editButton.setIcon(\"lucide-pencil\");\r\n                if (nameBox.getValue()) {\r\n                    entry.name = nameBox.getValue();\r\n                    namePar.setText(entry.name);\r\n                    await saveTracker(tracker, this.app, getSectionInfo());\r\n                }\r\n            } else {\r\n                namePar.hidden = true;\r\n                nameBox.inputEl.hidden = false;\r\n                nameBox.setValue(entry.name);\r\n                editButton.setIcon(\"lucide-check\");\r\n            }\r\n        });\r\n    new ButtonComponent(entryButtons)\r\n        .setClass(\"clickable-icon\")\r\n        .setTooltip(\"Remove\")\r\n        .setIcon(\"lucide-trash\")\r\n        .onClick(async () => {\r\n            removeEntry(tracker.entries, entry);\r\n            await saveTracker(tracker, this.app, getSectionInfo());\r\n        });\r\n\r\n    if (entry.subEntries) {\r\n        for (let sub of entry.subEntries)\r\n            addEditableTableRow(tracker, sub, table, newSegmentNameBox, running, getSectionInfo, settings, indent + 1);\r\n    }\r\n}\r\n"],
  "mappings": "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",
  "names": []
}
 diff --git a/test-vault/Cool Project.md b/test-vault/Cool Project.md index 908491d..e5299f4 100644 --- a/test-vault/Cool Project.md +++ b/test-vault/Cool Project.md @@ -2,7 +2,7 @@ These are the notes for my cool project. There's so much left to do! I wish I had a way to track the amount of time I spend on each part of the project. ```simple-time-tracker -{"entries":[{"name":"Think about project","startTime":1664305777,"endTime":1664308788},{"name":"Create project note","startTime":1664308810,"endTime":1664308815},{"name":"Work on project","startTime":1664308830,"endTime":1664309301},{"name":"Segment 4","startTime":1664364444,"endTime":1664364449},{"name":"Segment 5","startTime":1664364495,"endTime":1664364498},{"name":"Segment 6","startTime":1664458520,"endTime":1664458523},{"name":"Segment 7","startTime":1664460326,"endTime":1664460329}]} +{"entries":[{"name":"Segment 1","startTime":1666189948,"endTime":1666189951,"subEntries":null},{"name":"Segment 2","startTime":1666189953,"endTime":1666189961,"subEntries":null},{"name":"Segment 3","startTime":null,"endTime":null,"subEntries":[{"name":"Part 1","startTime":1666189962,"endTime":1666189995,"subEntries":null},{"name":"Part 2","startTime":1666190004,"endTime":1666190025,"subEntries":null},{"name":"Part 3","startTime":1666190094,"endTime":1666190101,"subEntries":null}]},{"name":"Segment 4","startTime":1666190088,"endTime":1666190091,"subEntries":null}]} ``` ``` @@ -12,7 +12,4 @@ Work on project,22-09-27 10:00:30,22-09-27 10:08:21,7m 51s Segment 4,22-09-28 01:27:24,22-09-28 01:27:29,5s Segment 5,22-09-28 01:28:15,22-09-28 01:28:18,3s -``` - - - +``` \ No newline at end of file