From 93ecd63a73d574af58d4f1908b7c30fcf59d4b3a Mon Sep 17 00:00:00 2001 From: Ellpeck Date: Tue, 27 Sep 2022 16:06:40 +0200 Subject: [PATCH] some work --- src/main.ts | 19 +++++- src/tracker.ts | 65 +++++++++++++++++++ .../obsidian-simple-time-tracker/main.js | 58 ++++++++++++++++- test-vault/track-note-test.md | 3 +- 4 files changed, 139 insertions(+), 6 deletions(-) create mode 100644 src/tracker.ts diff --git a/src/main.ts b/src/main.ts index 86026c1..6a3a55b 100644 --- a/src/main.ts +++ b/src/main.ts @@ -1,6 +1,7 @@ -import { Plugin } from "obsidian"; +import { ButtonComponent, MarkdownView, Plugin, TextComponent } from "obsidian"; import { defaultSettings, SimpleTimeTrackerSettings } from "./settings"; import { SimpleTimeTrackerSettingsTab } from "./settings-tab"; +import { Tracker } from "./tracker"; export default class SimpleTimeTrackerPlugin extends Plugin { @@ -11,10 +12,22 @@ export default class SimpleTimeTrackerPlugin extends Plugin { this.addSettingTab(new SimpleTimeTrackerSettingsTab(this.app, this)); - this.registerMarkdownCodeBlockProcessor("simple-time-tracker", (s, e) => { + this.registerMarkdownCodeBlockProcessor("simple-time-tracker", (s, e, i) => { e.empty(); - e.addClass("simple-time-tracker"); + + let tracker = Tracker.load(s); + + let name = new TextComponent(e) + .setPlaceholder("Name this segment"); + new ButtonComponent(e) + .setButtonText("Start") + .onClick(() => { + tracker.start(name.getValue()); + + // TODO how do we save to the code block?? + tracker.save(); + }); }); } diff --git a/src/tracker.ts b/src/tracker.ts new file mode 100644 index 0000000..cb3fdbb --- /dev/null +++ b/src/tracker.ts @@ -0,0 +1,65 @@ +import { MarkdownSectionInformation } from "obsidian"; + +export class Tracker { + + entries: Entry[] = []; + + display(element: HTMLElement): void { + let list = element.createEl("ul"); + for (let entry of this.entries) + list.createEl("li", { text: entry.toString() }); + } + + + start(name: string): void { + // date constructor returns the current date + let entry = new Entry(name, new Date()); + this.entries.push(entry); + } + + end(): void { + + } + + save(): void { + // TODO save + JSON.stringify(this); + } + + static load(json: string): Tracker { + if (json) { + try { + return JSON.parse(json); + } catch (e) { + console.log(`Failed to parse Tracker from ${json}`); + } + } + return new Tracker(); + } +} + +export class Entry { + + private name: string; + private startTime: Date; + private endTime: Date; + + constructor(name: string, startTime: Date) { + this.name = name; + this.startTime = startTime; + } + + toString(): string { + let ret = ""; + if (this.name) + ret += `${this.name}: `; + + // if the days or months are different, we want to add the full date + if (this.startTime.getDay() != this.endTime.getDay() || this.startTime.getMonth() != this.endTime.getMonth()) { + ret += `${this.startTime.toLocaleString()} - ${this.endTime.toLocaleString()}`; + } else { + ret += `${this.startTime.toLocaleTimeString()} - ${this.endTime.toLocaleTimeString()}`; + } + return ret; + } +} diff --git a/test-vault/.obsidian/plugins/obsidian-simple-time-tracker/main.js b/test-vault/.obsidian/plugins/obsidian-simple-time-tracker/main.js index 3e1bbde..17a0001 100644 --- a/test-vault/.obsidian/plugins/obsidian-simple-time-tracker/main.js +++ b/test-vault/.obsidian/plugins/obsidian-simple-time-tracker/main.js @@ -71,15 +71,69 @@ var SimpleTimeTrackerSettingsTab = class extends import_obsidian.PluginSettingTa } }; +// src/tracker.ts +var Tracker = class { + constructor() { + this.entries = []; + } + display(element) { + let list = element.createEl("ul"); + for (let entry of this.entries) + list.createEl("li", { text: entry.toString() }); + } + start(name) { + let entry = new Entry(name, new Date()); + this.entries.push(entry); + } + end() { + } + save() { + JSON.stringify(this); + } + static load(json) { + if (json) { + try { + return JSON.parse(json); + } catch (e) { + console.log(`Failed to parse Tracker from ${json}`); + } + } + return new Tracker(); + } +}; +var Entry = class { + constructor(name, startTime) { + this.name = name; + this.startTime = startTime; + } + toString() { + let ret = ""; + if (this.name) + ret += `${this.name}: `; + if (this.startTime.getDay() != this.endTime.getDay() || this.startTime.getMonth() != this.endTime.getMonth()) { + ret += `${this.startTime.toLocaleString()} - ${this.endTime.toLocaleString()}`; + } else { + ret += `${this.startTime.toLocaleTimeString()} - ${this.endTime.toLocaleTimeString()}`; + } + return ret; + } +}; + // src/main.ts var SimpleTimeTrackerPlugin = class extends import_obsidian2.Plugin { onload() { return __async(this, null, function* () { yield this.loadSettings(); this.addSettingTab(new SimpleTimeTrackerSettingsTab(this.app, this)); - this.registerMarkdownCodeBlockProcessor("simple-time-tracker", (s, e) => { + this.registerMarkdownCodeBlockProcessor("simple-time-tracker", (s, e, i) => { e.empty(); e.addClass("simple-time-tracker"); + let tracker = Tracker.load(s); + let name = new import_obsidian2.TextComponent(e).setPlaceholder("Name this segment"); + new import_obsidian2.ButtonComponent(e).setButtonText("Start").onClick(() => { + tracker.start(name.getValue()); + tracker.save(); + }); }); }); } @@ -94,4 +148,4 @@ var SimpleTimeTrackerPlugin = class extends import_obsidian2.Plugin { }); } }; -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/main.ts", "src/settings.ts", "src/settings-tab.ts", "src/tracker.ts"],
  "sourcesContent": ["import { ButtonComponent, MarkdownView, Plugin, TextComponent } from \"obsidian\";\r\nimport { defaultSettings, SimpleTimeTrackerSettings } from \"./settings\";\r\nimport { SimpleTimeTrackerSettingsTab } from \"./settings-tab\";\r\nimport { Tracker } 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\te.empty();\r\n\t\t\te.addClass(\"simple-time-tracker\");\r\n\r\n\t\t\tlet tracker = Tracker.load(s);\r\n\r\n\t\t\tlet name = new TextComponent(e)\r\n\t\t\t\t.setPlaceholder(\"Name this segment\");\r\n\t\t\tnew ButtonComponent(e)\r\n\t\t\t\t.setButtonText(\"Start\")\r\n\t\t\t\t.onClick(() => {\r\n\t\t\t\t\ttracker.start(name.getValue());\r\n\r\n\t\t\t\t\t// TODO how do we save to the code block??\r\n\t\t\t\t\ttracker.save();\r\n\t\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\r\n};\r\n\r\nexport interface SimpleTimeTrackerSettings {\r\n\r\n}\r\n", "import { App, PluginSettingTab } from \"obsidian\";\r\nimport SimpleTimeTrackerPlugin from \"./main\";\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: \"Simple Time Tracker Settings\" });\r\n\r\n        // TODO settings go here\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 { MarkdownSectionInformation } from \"obsidian\";\n\nexport class Tracker {\n\n    entries: Entry[] = [];\n\n    display(element: HTMLElement): void {\n        let list = element.createEl(\"ul\");\n        for (let entry of this.entries)\n            list.createEl(\"li\", { text: entry.toString() });\n    }\n\n\n    start(name: string): void {\n        // date constructor returns the current date\n        let entry = new Entry(name, new Date());\n        this.entries.push(entry);\n    }\n\n    end(): void {\n\n    }\n\n    save(): void {\n        // TODO save\n        JSON.stringify(this);\n    }\n\n    static load(json: string): Tracker {\n        if (json) {\n            try {\n                return JSON.parse(json);\n            } catch (e) {\n                console.log(`Failed to parse Tracker from ${json}`);\n            }\n        }\n        return new Tracker();\n    }\n}\n\nexport class Entry {\n\n    private name: string;\n    private startTime: Date;\n    private endTime: Date;\n\n    constructor(name: string, startTime: Date) {\n        this.name = name;\n        this.startTime = startTime;\n    }\n\n    toString(): string {\n        let ret = \"\";\n        if (this.name)\n            ret += `${this.name}: `;\n\n        // if the days or months are different, we want to add the full date\n        if (this.startTime.getDay() != this.endTime.getDay() || this.startTime.getMonth() != this.endTime.getMonth()) {\n            ret += `${this.startTime.toLocaleString()} - ${this.endTime.toLocaleString()}`;\n        } else {\n            ret += `${this.startTime.toLocaleTimeString()} - ${this.endTime.toLocaleTimeString()}`;\n        }\n        return ret;\n    }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA,uBAAqE;;;ACA9D,IAAM,kBAA6C;;;ACA1D,sBAAsC;AAG/B,iDAA2C,iCAAiB;AAAA,EAI/D,YAAY,KAAU,QAAiC;AACnD,UAAM,KAAK;AACX,SAAK,SAAS;AAAA;AAAA,EAGlB,UAAgB;AACZ,SAAK,YAAY;AACjB,SAAK,YAAY,SAAS,MAAM,EAAE,MAAM;AAIxC,SAAK,YAAY,SAAS;AAC1B,SAAK,YAAY,SAAS,KAAK,EAAE,MAAM;AACvC,SAAK,YAAY,SAAS,KAAK,EAAE,MAAM,gCAClC,SAAS,OAAO,EAAE,MAAM,EAAE,KAAK,+CAA+C,KAAK;AAAA;AAAA;;;ACnBzF,oBAAc;AAAA,EAAd,cAFP;AAII,mBAAmB;AAAA;AAAA,EAEnB,QAAQ,SAA4B;AAChC,QAAI,OAAO,QAAQ,SAAS;AAC5B,aAAS,SAAS,KAAK;AACnB,WAAK,SAAS,MAAM,EAAE,MAAM,MAAM;AAAA;AAAA,EAI1C,MAAM,MAAoB;AAEtB,QAAI,QAAQ,IAAI,MAAM,MAAM,IAAI;AAChC,SAAK,QAAQ,KAAK;AAAA;AAAA,EAGtB,MAAY;AAAA;AAAA,EAIZ,OAAa;AAET,SAAK,UAAU;AAAA;AAAA,SAGZ,KAAK,MAAuB;AAC/B,QAAI,MAAM;AACN,UAAI;AACA,eAAO,KAAK,MAAM;AAAA,eACb,GAAP;AACE,gBAAQ,IAAI,gCAAgC;AAAA;AAAA;AAGpD,WAAO,IAAI;AAAA;AAAA;AAIZ,kBAAY;AAAA,EAMf,YAAY,MAAc,WAAiB;AACvC,SAAK,OAAO;AACZ,SAAK,YAAY;AAAA;AAAA,EAGrB,WAAmB;AACf,QAAI,MAAM;AACV,QAAI,KAAK;AACL,aAAO,GAAG,KAAK;AAGnB,QAAI,KAAK,UAAU,YAAY,KAAK,QAAQ,YAAY,KAAK,UAAU,cAAc,KAAK,QAAQ,YAAY;AAC1G,aAAO,GAAG,KAAK,UAAU,sBAAsB,KAAK,QAAQ;AAAA,WACzD;AACH,aAAO,GAAG,KAAK,UAAU,0BAA0B,KAAK,QAAQ;AAAA;AAEpE,WAAO;AAAA;AAAA;;;AHzDf,4CAAqD,wBAAO;AAAA,EAIrD,SAAwB;AAAA;AAC7B,YAAM,KAAK;AAEX,WAAK,cAAc,IAAI,6BAA6B,KAAK,KAAK;AAE9D,WAAK,mCAAmC,uBAAuB,CAAC,GAAG,GAAG,MAAM;AAC3E,UAAE;AACF,UAAE,SAAS;AAEX,YAAI,UAAU,QAAQ,KAAK;AAE3B,YAAI,OAAO,IAAI,+BAAc,GAC3B,eAAe;AACjB,YAAI,iCAAgB,GAClB,cAAc,SACd,QAAQ,MAAM;AACd,kBAAQ,MAAM,KAAK;AAGnB,kBAAQ;AAAA;AAAA;AAAA;AAAA;AAAA,EAKN,eAAe;AAAA;AACpB,WAAK,WAAW,OAAO,OAAO,IAAI,iBAAiB,MAAM,KAAK;AAAA;AAAA;AAAA,EAGzD,eAAe;AAAA;AACpB,YAAM,KAAK,SAAS,KAAK;AAAA;AAAA;AAAA;",
  "names": []
}
 diff --git a/test-vault/track-note-test.md b/test-vault/track-note-test.md index 8f2ca5a..8938bda 100644 --- a/test-vault/track-note-test.md +++ b/test-vault/track-note-test.md @@ -2,4 +2,5 @@ This is a time tracker: ```simple-time-tracker -``` \ No newline at end of file +``` +