From 0a47f4c98eb374b63e8898d05bf5ba5f1a2381d0 Mon Sep 17 00:00:00 2001 From: Bram Adams <3282661+bramses@users.noreply.github.com> Date: Thu, 15 Dec 2022 21:55:51 -0600 Subject: [PATCH] vault backup: 2022-12-15 21:55:51 --- .obsidian/plugins/lumberjack-obsidian/main.js | 680 ++++++++++++++++++ .../plugins/lumberjack-obsidian/manifest.json | 10 + .../plugins/recent-files-obsidian/data.json | 32 +- .obsidian/workspace.json | 16 +- README.md | 2 + 5 files changed, 716 insertions(+), 24 deletions(-) create mode 100644 .obsidian/plugins/lumberjack-obsidian/main.js create mode 100644 .obsidian/plugins/lumberjack-obsidian/manifest.json diff --git a/.obsidian/plugins/lumberjack-obsidian/main.js b/.obsidian/plugins/lumberjack-obsidian/main.js new file mode 100644 index 0000000..043c31a --- /dev/null +++ b/.obsidian/plugins/lumberjack-obsidian/main.js @@ -0,0 +1,680 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ROLLUP +if you want to view the source visit the plugins github repository +*/ + +'use strict'; + +var obsidian = require('obsidian'); + +function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } + +var obsidian__default = /*#__PURE__*/_interopDefaultLegacy(obsidian); + +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ + +function __awaiter(thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +} + +const DEFAULT_DAILY_NOTE_FORMAT = "YYYY-MM-DD"; +const DEFAULT_WEEKLY_NOTE_FORMAT = "gggg-[W]ww"; +const DEFAULT_MONTHLY_NOTE_FORMAT = "YYYY-MM"; +const DEFAULT_QUARTERLY_NOTE_FORMAT = "YYYY-[Q]Q"; +const DEFAULT_YEARLY_NOTE_FORMAT = "YYYY"; + +function shouldUsePeriodicNotesSettings(periodicity) { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const periodicNotes = window.app.plugins.getPlugin("periodic-notes"); + return periodicNotes && periodicNotes.settings?.[periodicity]?.enabled; +} +/** + * Read the user settings for the `daily-notes` plugin + * to keep behavior of creating a new note in-sync. + */ +function getDailyNoteSettings() { + try { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const { internalPlugins, plugins } = window.app; + if (shouldUsePeriodicNotesSettings("daily")) { + const { format, folder, template } = plugins.getPlugin("periodic-notes")?.settings?.daily || {}; + return { + format: format || DEFAULT_DAILY_NOTE_FORMAT, + folder: folder?.trim() || "", + template: template?.trim() || "", + }; + } + const { folder, format, template } = internalPlugins.getPluginById("daily-notes")?.instance?.options || {}; + return { + format: format || DEFAULT_DAILY_NOTE_FORMAT, + folder: folder?.trim() || "", + template: template?.trim() || "", + }; + } + catch (err) { + console.info("No custom daily note settings found!", err); + } +} +/** + * Read the user settings for the `weekly-notes` plugin + * to keep behavior of creating a new note in-sync. + */ +function getWeeklyNoteSettings() { + try { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const pluginManager = window.app.plugins; + const calendarSettings = pluginManager.getPlugin("calendar")?.options; + const periodicNotesSettings = pluginManager.getPlugin("periodic-notes")?.settings?.weekly; + if (shouldUsePeriodicNotesSettings("weekly")) { + return { + format: periodicNotesSettings.format || DEFAULT_WEEKLY_NOTE_FORMAT, + folder: periodicNotesSettings.folder?.trim() || "", + template: periodicNotesSettings.template?.trim() || "", + }; + } + const settings = calendarSettings || {}; + return { + format: settings.weeklyNoteFormat || DEFAULT_WEEKLY_NOTE_FORMAT, + folder: settings.weeklyNoteFolder?.trim() || "", + template: settings.weeklyNoteTemplate?.trim() || "", + }; + } + catch (err) { + console.info("No custom weekly note settings found!", err); + } +} +/** + * Read the user settings for the `periodic-notes` plugin + * to keep behavior of creating a new note in-sync. + */ +function getMonthlyNoteSettings() { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const pluginManager = window.app.plugins; + try { + const settings = (shouldUsePeriodicNotesSettings("monthly") && + pluginManager.getPlugin("periodic-notes")?.settings?.monthly) || + {}; + return { + format: settings.format || DEFAULT_MONTHLY_NOTE_FORMAT, + folder: settings.folder?.trim() || "", + template: settings.template?.trim() || "", + }; + } + catch (err) { + console.info("No custom monthly note settings found!", err); + } +} +/** + * Read the user settings for the `periodic-notes` plugin + * to keep behavior of creating a new note in-sync. + */ +function getQuarterlyNoteSettings() { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const pluginManager = window.app.plugins; + try { + const settings = (shouldUsePeriodicNotesSettings("quarterly") && + pluginManager.getPlugin("periodic-notes")?.settings?.quarterly) || + {}; + return { + format: settings.format || DEFAULT_QUARTERLY_NOTE_FORMAT, + folder: settings.folder?.trim() || "", + template: settings.template?.trim() || "", + }; + } + catch (err) { + console.info("No custom quarterly note settings found!", err); + } +} +/** + * Read the user settings for the `periodic-notes` plugin + * to keep behavior of creating a new note in-sync. + */ +function getYearlyNoteSettings() { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const pluginManager = window.app.plugins; + try { + const settings = (shouldUsePeriodicNotesSettings("yearly") && + pluginManager.getPlugin("periodic-notes")?.settings?.yearly) || + {}; + return { + format: settings.format || DEFAULT_YEARLY_NOTE_FORMAT, + folder: settings.folder?.trim() || "", + template: settings.template?.trim() || "", + }; + } + catch (err) { + console.info("No custom yearly note settings found!", err); + } +} + +// Credit: @creationix/path.js +function join(...partSegments) { + // Split the inputs into a list of path commands. + let parts = []; + for (let i = 0, l = partSegments.length; i < l; i++) { + parts = parts.concat(partSegments[i].split("/")); + } + // Interpret the path commands to get the new resolved path. + const newParts = []; + for (let i = 0, l = parts.length; i < l; i++) { + const part = parts[i]; + // Remove leading and trailing slashes + // Also remove "." segments + if (!part || part === ".") + continue; + // Push new path segments. + else + newParts.push(part); + } + // Preserve the initial slash if there was one. + if (parts[0] === "") + newParts.unshift(""); + // Turn back into a single string path. + return newParts.join("/"); +} +async function ensureFolderExists(path) { + const dirs = path.replace(/\\/g, "/").split("/"); + dirs.pop(); // remove basename + if (dirs.length) { + const dir = join(...dirs); + if (!window.app.vault.getAbstractFileByPath(dir)) { + await window.app.vault.createFolder(dir); + } + } +} +async function getNotePath(directory, filename) { + if (!filename.endsWith(".md")) { + filename += ".md"; + } + const path = obsidian__default["default"].normalizePath(join(directory, filename)); + await ensureFolderExists(path); + return path; +} +async function getTemplateInfo(template) { + const { metadataCache, vault } = window.app; + const templatePath = obsidian__default["default"].normalizePath(template); + if (templatePath === "/") { + return Promise.resolve(["", null]); + } + try { + const templateFile = metadataCache.getFirstLinkpathDest(templatePath, ""); + const contents = await vault.cachedRead(templateFile); + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const IFoldInfo = window.app.foldManager.load(templateFile); + return [contents, IFoldInfo]; + } + catch (err) { + console.error(`Failed to read the daily note template '${templatePath}'`, err); + new obsidian__default["default"].Notice("Failed to read the daily note template"); + return ["", null]; + } +} + +/** + * dateUID is a way of weekly identifying daily/weekly/monthly notes. + * They are prefixed with the granularity to avoid ambiguity. + */ +function getDateUID(date, granularity = "day") { + const ts = date.clone().startOf(granularity).format(); + return `${granularity}-${ts}`; +} +function removeEscapedCharacters(format) { + return format.replace(/\[[^\]]*\]/g, ""); // remove everything within brackets +} +/** + * XXX: When parsing dates that contain both week numbers and months, + * Moment choses to ignore the week numbers. For the week dateUID, we + * want the opposite behavior. Strip the MMM from the format to patch. + */ +function isFormatAmbiguous(format, granularity) { + if (granularity === "week") { + const cleanFormat = removeEscapedCharacters(format); + return (/w{1,2}/i.test(cleanFormat) && + (/M{1,4}/.test(cleanFormat) || /D{1,4}/.test(cleanFormat))); + } + return false; +} +function getDateFromFile(file, granularity) { + return getDateFromFilename(file.basename, granularity); +} +function getDateFromFilename(filename, granularity) { + const getSettings = { + day: getDailyNoteSettings, + week: getWeeklyNoteSettings, + month: getMonthlyNoteSettings, + quarter: getQuarterlyNoteSettings, + year: getYearlyNoteSettings, + }; + const format = getSettings[granularity]().format.split("/").pop(); + const noteDate = window.moment(filename, format, true); + if (!noteDate.isValid()) { + return null; + } + if (isFormatAmbiguous(format, granularity)) { + if (granularity === "week") { + const cleanFormat = removeEscapedCharacters(format); + if (/w{1,2}/i.test(cleanFormat)) { + return window.moment(filename, + // If format contains week, remove day & month formatting + format.replace(/M{1,4}/g, "").replace(/D{1,4}/g, ""), false); + } + } + } + return noteDate; +} + +class DailyNotesFolderMissingError extends Error { +} +/** + * This function mimics the behavior of the daily-notes plugin + * so it will replace {{date}}, {{title}}, and {{time}} with the + * formatted timestamp. + * + * Note: it has an added bonus that it's not 'today' specific. + */ +async function createDailyNote(date) { + const app = window.app; + const { vault } = app; + const moment = window.moment; + const { template, format, folder } = getDailyNoteSettings(); + const [templateContents, IFoldInfo] = await getTemplateInfo(template); + const filename = date.format(format); + const normalizedPath = await getNotePath(folder, filename); + try { + const createdFile = await vault.create(normalizedPath, templateContents + .replace(/{{\s*date\s*}}/gi, filename) + .replace(/{{\s*time\s*}}/gi, moment().format("HH:mm")) + .replace(/{{\s*title\s*}}/gi, filename) + .replace(/{{\s*(date|time)\s*(([+-]\d+)([yqmwdhs]))?\s*(:.+?)?}}/gi, (_, _timeOrDate, calc, timeDelta, unit, momentFormat) => { + const now = moment(); + const currentDate = date.clone().set({ + hour: now.get("hour"), + minute: now.get("minute"), + second: now.get("second"), + }); + if (calc) { + currentDate.add(parseInt(timeDelta, 10), unit); + } + if (momentFormat) { + return currentDate.format(momentFormat.substring(1).trim()); + } + return currentDate.format(format); + }) + .replace(/{{\s*yesterday\s*}}/gi, date.clone().subtract(1, "day").format(format)) + .replace(/{{\s*tomorrow\s*}}/gi, date.clone().add(1, "d").format(format))); + // eslint-disable-next-line @typescript-eslint/no-explicit-any + app.foldManager.save(createdFile, IFoldInfo); + return createdFile; + } + catch (err) { + console.error(`Failed to create file: '${normalizedPath}'`, err); + new obsidian__default["default"].Notice("Unable to create new file."); + } +} +function getDailyNote(date, dailyNotes) { + return dailyNotes[getDateUID(date, "day")] ?? null; +} +function getAllDailyNotes() { + /** + * Find all daily notes in the daily note folder + */ + const { vault } = window.app; + const { folder } = getDailyNoteSettings(); + const dailyNotesFolder = vault.getAbstractFileByPath(obsidian__default["default"].normalizePath(folder)); + if (!dailyNotesFolder) { + throw new DailyNotesFolderMissingError("Failed to find daily notes folder"); + } + const dailyNotes = {}; + obsidian__default["default"].Vault.recurseChildren(dailyNotesFolder, (note) => { + if (note instanceof obsidian__default["default"].TFile) { + const date = getDateFromFile(note, "day"); + if (date) { + const dateString = getDateUID(date, "day"); + dailyNotes[dateString] = note; + } + } + }); + return dailyNotes; +} +var createDailyNote_1 = createDailyNote; +var getAllDailyNotes_1 = getAllDailyNotes; +var getDailyNote_1 = getDailyNote; + +const DEFAULT_SETTINGS = { + logPrefix: '- [ ] ', + useTimestamp: true, + alwaysOpenInNewLeaf: false, + inboxFilePath: "Inbox", + newDraftFilenameTemplate: "YYYYMMDDHHmmss", + targetHeader: "Journal", + timestampFormat: "HH:mm" +}; +const editModeState = { + state: { mode: "source" }, + active: true, + focus: true +}; +class LumberjackPlugin extends obsidian.Plugin { + onload() { + return __awaiter(this, void 0, void 0, function* () { + console.debug('Loading the Lumberjack plugin. 𖥧'); + yield this.loadSettings(); + this.addCommand({ + id: 'lumberjack-log', + name: 'Log something new on your daily note', + callback: () => { + this.newLog(this.settings.alwaysOpenInNewLeaf); + } + }); + this.addSettingTab(new LumberjackSettingsTab(this.app, this)); + this.registerObsidianProtocolHandler("log", (𖣂) => __awaiter(this, void 0, void 0, function* () { + // Need to handle multiple vaults, I guess. Sigh. + const parameters = 𖣂; + for (const parameter in parameters) { // not yet using parameters + parameters[parameter] = parameters[parameter]; // Thanks to @Vinzent03 for a clear-cut (pun intended) example of how to do this + } + this.newLog(this.settings.alwaysOpenInNewLeaf); + })); + this.registerObsidianProtocolHandler("timber", (𖣂) => __awaiter(this, void 0, void 0, function* () { + // Need to handle multiple vaults, I guess. Sigh. + const parameters = 𖣂; + for (const parameter in parameters) { // not yet actually using parameters + parameters[parameter] = parameters[parameter]; // Thanks to @Vinzent03 for a clear-cut (pun intended) example of how to do this + } + if (parameters.name) ; + else { + this.timber(); + } + })); + }); + } + // newLog creates a new item with a user-configured prefix under a user-configured heading in the daily note, and gives them editing ability in that position immediately. + newLog(openFileInNewLeaf) { + return __awaiter(this, void 0, void 0, function* () { + // find or create the daily note + let dailyNote = getDailyNote_1(obsidian.moment(), getAllDailyNotes_1()); + if (!dailyNote) { + dailyNote = yield createDailyNote_1(obsidian.moment()); + } + // set up the timestamp string, if the user is using it + let tampTime; + if (this.settings.useTimestamp) { + tampTime = obsidian.moment().format(this.settings.timestampFormat) + " "; + } + else { + tampTime = ""; + } + // open the daily note in edit mode and get the editor + yield this.app.workspace.openLinkText(dailyNote.name, dailyNote.path, openFileInNewLeaf, editModeState); + if (this.app.workspace.getActiveViewOfType(obsidian.MarkdownView)) { + let editor = this.app.workspace.getActiveViewOfType(obsidian.MarkdownView).editor; + if (editor == null) { + new obsidian.Notice(`Could not find the daily note. Check your daily note settings, or report this as a bug on the plugin repository.`); + return; + } + // establish the line prefix to add, if anything + let linePrefix = ` +${this.settings.logPrefix}${tampTime}`; + // Make sure the editor has focus + editor.focus(); + // Inserting the cursor + // The goal is to set the cursor either at the end of the user's target section, if set, or at the end of the note + // find the section to insert the log item into and set the insert position to append into it, or set the insert position to the end of the note + let sections = this.app.metadataCache.getFileCache(dailyNote).headings; + if (!sections) { + // The daily note does not have sections. Insert the log item at the bottom of the note. + editor.setCursor(editor.lastLine()); + editor.replaceSelection(linePrefix); + editor.setCursor(editor.lastLine()); + } + else { + if (this.settings.targetHeader != "") { // If the user has set a target header + // need to figure out which line the _next_ section is on, if any, then use that line number in the functions below + let targetSection = sections.find((eachSection) => (eachSection.heading == this.settings.targetHeader)); // does the heading we're looking for exist? + if (targetSection) { // The target section exists + let nextSection = sections.find((eachSection) => ((eachSection.position.start.line > targetSection.position.start.line) && (eachSection.level <= targetSection.level))); // matches sections _after_ our target, with the same level or greater + console.debug(nextSection); + if (!nextSection) { + // There is no section following the target section. Look for the end of the document + // A better approach would append the item at the end of the content inside the user's target section, because it's possible that someone would put more stuff in their daily note without a following section, but that will have to be implemented later. + console.debug("No section follows the target section. Inserting the log item at the end of the target section."); + editor.setCursor(editor.lastLine()); + editor.replaceSelection(linePrefix); + editor.setCursor(editor.lastLine()); + } + else { + if (typeof (nextSection) !== undefined) { // The search for a following section did not return undefined, therefore it exists + // Find out if there is a preceding blank line before the next section. E.g., does the user use linebreaks to separate content in edit mode? If so, inserting the next item after that line break will look messy. + if (editor.getLine(nextSection.position.start.line - 1) === editor.getLine(targetSection.position.start.line)) { + // There are no lines between the next section and the target section. Insert the log item immediately after the target section. + editor.setCursor(nextSection.position.start.line - 1); + editor.replaceSelection(linePrefix); + editor.setCursor(nextSection.position.start.line); + } + else if (editor.getLine(nextSection.position.start.line - 1).length > 0) { + // The line just before the next section header is not blank. Insert the log item just before the next section, without a line break. + console.debug("No blank lines found between the target section and the next section."); + editor.setCursor(nextSection.position.start.line - 2); + editor.replaceSelection(linePrefix); + editor.setCursor(nextSection.position.start.line); + } + else { + console.debug(`The line before the next section has 0 length. It is line number: ${nextSection.position.start.line - 1}`); + // The line just before the next section header is blank. It's likely that the user uses line breaks to clean up their note in edit mode. + // The approach here is to iterate over the lines preceding the next section header until a non-blank line is reached, then insert the log item at (iterator.position.start.line + 1)... + let lastBlankLineFound = false; + let noBlankLines = false; + let lastLineBeforeLineBreakIteratorLineNumber = nextSection.position.start.line - 1; // `lastLineBeforeLineBreakIteratorNumber: this wordy variable represents the number of the last-line-before-line-break iterator's current line + while (lastBlankLineFound == false) { + if (lastLineBeforeLineBreakIteratorLineNumber == 0) { // This condition would mean the iterator found the start of the document + noBlankLines = true; + lastBlankLineFound = true; + } + else { + let blankLineFinderCurrentLine = editor.getLine(lastLineBeforeLineBreakIteratorLineNumber); + if (blankLineFinderCurrentLine.toString() === "") { + lastBlankLineFound = true; + console.debug("found the last line"); + } + else { + lastLineBeforeLineBreakIteratorLineNumber = lastLineBeforeLineBreakIteratorLineNumber - 1; // Move to the next line up + } + } + } + if (noBlankLines) { // this means the iterator failed to find any blanks at all; insert the log item just before the next section. + console.debug("No blank lines found."); + editor.setCursor(nextSection.position.start.line - 1); + editor.replaceSelection(linePrefix); + editor.setCursor(nextSection.position.start.line - 1); + } + else { // There were an arbitrary number of blank lines before the next section header. Insert the log item _after_ the last (length > 0) line before the next section header. + console.debug(`Iterator stopped at line ${lastLineBeforeLineBreakIteratorLineNumber}, with text ${editor.getLine(lastLineBeforeLineBreakIteratorLineNumber)}`); + editor.setCursor(lastLineBeforeLineBreakIteratorLineNumber - 1); + editor.replaceSelection(linePrefix); + editor.setCursor(lastLineBeforeLineBreakIteratorLineNumber); + } + } + } + } + } + else { + new obsidian.Notice(`Could not run the Log command. Your daily note does not contain the target section you've specified in Preferences → Lumberjack—that is, the heading "${this.settings.targetHeader}". Please enter a heading that exists in your daily note, or leave this setting blank.`); + return; + } + } + else { + // The user has not set a target header. Insert the log item at the bottom of the note. + editor.setCursor(editor.lastLine()); + editor.replaceSelection(linePrefix); + editor.setCursor(editor.lastLine()); + } + } + } + }); + } + // // Log the thought in the background. + // // Not yet implemented. + // async ifATreeFallsInTheBackgroundDidItEverReallyFall(someData: string) { + // let dailyNote = getDailyNote(moment(), getAllDailyNotes()); + // if (!dailyNote) { dailyNote = await createDailyNote(moment()); } + // let tampTime: string; + // if (this.settings.useTimestamp) { + // tampTime = moment().format("HH:mm") + " "; + // } + // let dailyNoteOldText = await this.app.vault.read(dailyNote); // unsure about using .read versus .cachedRead here. as this is meant to be used when Obsidian is in the background + // let dailyNoteNewText = `${dailyNoteOldText} + // ${this.settings.logPrefix}${tampTime}${someData}` + // this.app.vault.modify(dailyNote, dailyNoteNewText) // write the new line in + // new Notice('Data "' + someData + '" logged to the daily note.'); + // } + timber() { + return __awaiter(this, void 0, void 0, function* () { + let zkUUIDNoteName = obsidian.moment().format(this.settings.newDraftFilenameTemplate); + const isInboxPathEmpty = this.settings.inboxFilePath === undefined || this.settings.inboxFilePath.trim() === ''; + const folderName = isInboxPathEmpty ? '' : this.settings.inboxFilePath; + const inboxPath = isInboxPathEmpty ? '' : `/${this.settings.inboxFilePath}/`; + console.debug(`${this.settings.inboxFilePath}`); + if (!isInboxPathEmpty && !(this.app.vault.getAbstractFileByPath(`${folderName}`))) { // In the future, handle folder creation as necessary. For now, error and tell the user if the inbox folder does not exist. + new obsidian.Notice(`Error. Lumberjack couldn't create the draft. Does the inbox folder you've set in Preferences -> Lumberjack 🪓🪵 exist?`); + return; + } + yield this.app.vault.create(`${inboxPath}${zkUUIDNoteName}.md`, ""); + yield this.app.workspace.openLinkText(zkUUIDNoteName, `${inboxPath}`, this.settings.alwaysOpenInNewLeaf, editModeState); + if (this.app.workspace.getActiveViewOfType(obsidian.MarkdownView)) { + let editor = this.app.workspace.getActiveViewOfType(obsidian.MarkdownView).editor; + if (editor == null) { + new obsidian.Notice(`Couldn't run the Timber command. Please report this as a bug in the GitHub repository for Lumberjack 🪓🪵`); + return; + } + editor.focus(); + let startChar = ""; + editor.setCursor(editor.lastLine()); + editor.replaceSelection(startChar); + editor.setCursor(editor.lastLine()); + } + }); + } + onunload() { + console.debug('Unloading the Lumberjack plugin. Watch out for splinters.'); + } + loadSettings() { + return __awaiter(this, void 0, void 0, function* () { + this.settings = Object.assign({}, DEFAULT_SETTINGS, yield this.loadData()); + }); + } + saveSettings() { + return __awaiter(this, void 0, void 0, function* () { + yield this.saveData(this.settings); + }); + } +} +class LumberjackSettingsTab extends obsidian.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + this.plugin = plugin; + } + display() { + let { containerEl } = this; + containerEl.empty(); + containerEl.createEl('h2', { text: 'Lumberjack Settings' }); + new obsidian.Setting(containerEl) + .setName('Target header') + .setDesc('Append logged items to a target header in your daily note') + .addText(text => text + .setPlaceholder(this.plugin.settings.targetHeader) + .setValue(this.plugin.settings.targetHeader) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.targetHeader = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Prefix for logging') + .setDesc('Sets a prefix for lines added via the log command') + .addText(text => text + .setPlaceholder('Prefix:') + .setValue(this.plugin.settings.logPrefix) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.logPrefix = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Timestamp') + .setDesc('If enabled, the log command will prefix newly added lines with a timestamp. (Changing this setting reloads the plugin.)') + .addToggle(toggle => toggle + .setValue(this.plugin.settings.useTimestamp) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.useTimestamp = value; + yield this.plugin.saveSettings(); + if (value) { + this.containerEl.appendChild(timestampFormatSetting.settingEl); + } + else { + timestampFormatSetting.settingEl.remove(); + } + }))); + new obsidian.Setting(containerEl) + .setName('Always open in a new pane') + .setDesc('If enabled, Lumberjack commands will always open in a new pane.') + .addToggle(toggle => toggle + .setValue(this.plugin.settings.alwaysOpenInNewLeaf) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.alwaysOpenInNewLeaf = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Inbox folder') + .setDesc('Set the destination for notes created with `obsidian://timber`, e.g., `My Notes/Inbox`. Do not include leading or trailing slashes.') + .addText(text => text + .setValue(this.plugin.settings.inboxFilePath) + .setPlaceholder(this.plugin.settings.inboxFilePath) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.inboxFilePath = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Filename for new drafts') + .setDesc('Set the filename template for new drafts created with `obsidian://timber`. Uses Moment formatting, same as daily notes. Default: YYYYMMDDHHmm') + .addText(text => text + .setValue(this.plugin.settings.newDraftFilenameTemplate) + .setPlaceholder(this.plugin.settings.newDraftFilenameTemplate) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.newDraftFilenameTemplate = value; + yield this.plugin.saveSettings(); + }))); + let timestampFormatSetting = new obsidian.Setting(containerEl) + .setName('Timestamp format') + .setDesc('Set the format for timestamp prefixes. Follows Moment.js formatting, same as Obsidian\'s core daily notes.') + .addText(text => text + .setValue(this.plugin.settings.timestampFormat) + .setPlaceholder(this.plugin.settings.timestampFormat) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.timestampFormat = value; + yield this.plugin.saveSettings(); + }))); + if (!this.plugin.settings.useTimestamp) { + timestampFormatSetting.settingEl.remove(); + } + } +} + +module.exports = LumberjackPlugin; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["node_modules/tslib/tslib.es6.js","node_modules/obsidian-daily-notes-interface/dist/main.js","main.ts"],"sourcesContent":["/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar obsidian = require('obsidian');\n\nconst DEFAULT_DAILY_NOTE_FORMAT = \"YYYY-MM-DD\";\nconst DEFAULT_WEEKLY_NOTE_FORMAT = \"gggg-[W]ww\";\nconst DEFAULT_MONTHLY_NOTE_FORMAT = \"YYYY-MM\";\nconst DEFAULT_QUARTERLY_NOTE_FORMAT = \"YYYY-[Q]Q\";\nconst DEFAULT_YEARLY_NOTE_FORMAT = \"YYYY\";\n\nfunction shouldUsePeriodicNotesSettings(periodicity) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const periodicNotes = window.app.plugins.getPlugin(\"periodic-notes\");\n    return periodicNotes && periodicNotes.settings?.[periodicity]?.enabled;\n}\n/**\n * Read the user settings for the `daily-notes` plugin\n * to keep behavior of creating a new note in-sync.\n */\nfunction getDailyNoteSettings() {\n    try {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        const { internalPlugins, plugins } = window.app;\n        if (shouldUsePeriodicNotesSettings(\"daily\")) {\n            const { format, folder, template } = plugins.getPlugin(\"periodic-notes\")?.settings?.daily || {};\n            return {\n                format: format || DEFAULT_DAILY_NOTE_FORMAT,\n                folder: folder?.trim() || \"\",\n                template: template?.trim() || \"\",\n            };\n        }\n        const { folder, format, template } = internalPlugins.getPluginById(\"daily-notes\")?.instance?.options || {};\n        return {\n            format: format || DEFAULT_DAILY_NOTE_FORMAT,\n            folder: folder?.trim() || \"\",\n            template: template?.trim() || \"\",\n        };\n    }\n    catch (err) {\n        console.info(\"No custom daily note settings found!\", err);\n    }\n}\n/**\n * Read the user settings for the `weekly-notes` plugin\n * to keep behavior of creating a new note in-sync.\n */\nfunction getWeeklyNoteSettings() {\n    try {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        const pluginManager = window.app.plugins;\n        const calendarSettings = pluginManager.getPlugin(\"calendar\")?.options;\n        const periodicNotesSettings = pluginManager.getPlugin(\"periodic-notes\")?.settings?.weekly;\n        if (shouldUsePeriodicNotesSettings(\"weekly\")) {\n            return {\n                format: periodicNotesSettings.format || DEFAULT_WEEKLY_NOTE_FORMAT,\n                folder: periodicNotesSettings.folder?.trim() || \"\",\n                template: periodicNotesSettings.template?.trim() || \"\",\n            };\n        }\n        const settings = calendarSettings || {};\n        return {\n            format: settings.weeklyNoteFormat || DEFAULT_WEEKLY_NOTE_FORMAT,\n            folder: settings.weeklyNoteFolder?.trim() || \"\",\n            template: settings.weeklyNoteTemplate?.trim() || \"\",\n        };\n    }\n    catch (err) {\n        console.info(\"No custom weekly note settings found!\", err);\n    }\n}\n/**\n * Read the user settings for the `periodic-notes` plugin\n * to keep behavior of creating a new note in-sync.\n */\nfunction getMonthlyNoteSettings() {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const pluginManager = window.app.plugins;\n    try {\n        const settings = (shouldUsePeriodicNotesSettings(\"monthly\") &&\n            pluginManager.getPlugin(\"periodic-notes\")?.settings?.monthly) ||\n            {};\n        return {\n            format: settings.format || DEFAULT_MONTHLY_NOTE_FORMAT,\n            folder: settings.folder?.trim() || \"\",\n            template: settings.template?.trim() || \"\",\n        };\n    }\n    catch (err) {\n        console.info(\"No custom monthly note settings found!\", err);\n    }\n}\n/**\n * Read the user settings for the `periodic-notes` plugin\n * to keep behavior of creating a new note in-sync.\n */\nfunction getQuarterlyNoteSettings() {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const pluginManager = window.app.plugins;\n    try {\n        const settings = (shouldUsePeriodicNotesSettings(\"quarterly\") &&\n            pluginManager.getPlugin(\"periodic-notes\")?.settings?.quarterly) ||\n            {};\n        return {\n            format: settings.format || DEFAULT_QUARTERLY_NOTE_FORMAT,\n            folder: settings.folder?.trim() || \"\",\n            template: settings.template?.trim() || \"\",\n        };\n    }\n    catch (err) {\n        console.info(\"No custom quarterly note settings found!\", err);\n    }\n}\n/**\n * Read the user settings for the `periodic-notes` plugin\n * to keep behavior of creating a new note in-sync.\n */\nfunction getYearlyNoteSettings() {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const pluginManager = window.app.plugins;\n    try {\n        const settings = (shouldUsePeriodicNotesSettings(\"yearly\") &&\n            pluginManager.getPlugin(\"periodic-notes\")?.settings?.yearly) ||\n            {};\n        return {\n            format: settings.format || DEFAULT_YEARLY_NOTE_FORMAT,\n            folder: settings.folder?.trim() || \"\",\n            template: settings.template?.trim() || \"\",\n        };\n    }\n    catch (err) {\n        console.info(\"No custom yearly note settings found!\", err);\n    }\n}\n\n// Credit: @creationix/path.js\nfunction join(...partSegments) {\n    // Split the inputs into a list of path commands.\n    let parts = [];\n    for (let i = 0, l = partSegments.length; i < l; i++) {\n        parts = parts.concat(partSegments[i].split(\"/\"));\n    }\n    // Interpret the path commands to get the new resolved path.\n    const newParts = [];\n    for (let i = 0, l = parts.length; i < l; i++) {\n        const part = parts[i];\n        // Remove leading and trailing slashes\n        // Also remove \".\" segments\n        if (!part || part === \".\")\n            continue;\n        // Push new path segments.\n        else\n            newParts.push(part);\n    }\n    // Preserve the initial slash if there was one.\n    if (parts[0] === \"\")\n        newParts.unshift(\"\");\n    // Turn back into a single string path.\n    return newParts.join(\"/\");\n}\nfunction basename(fullPath) {\n    let base = fullPath.substring(fullPath.lastIndexOf(\"/\") + 1);\n    if (base.lastIndexOf(\".\") != -1)\n        base = base.substring(0, base.lastIndexOf(\".\"));\n    return base;\n}\nasync function ensureFolderExists(path) {\n    const dirs = path.replace(/\\\\/g, \"/\").split(\"/\");\n    dirs.pop(); // remove basename\n    if (dirs.length) {\n        const dir = join(...dirs);\n        if (!window.app.vault.getAbstractFileByPath(dir)) {\n            await window.app.vault.createFolder(dir);\n        }\n    }\n}\nasync function getNotePath(directory, filename) {\n    if (!filename.endsWith(\".md\")) {\n        filename += \".md\";\n    }\n    const path = obsidian.normalizePath(join(directory, filename));\n    await ensureFolderExists(path);\n    return path;\n}\nasync function getTemplateInfo(template) {\n    const { metadataCache, vault } = window.app;\n    const templatePath = obsidian.normalizePath(template);\n    if (templatePath === \"/\") {\n        return Promise.resolve([\"\", null]);\n    }\n    try {\n        const templateFile = metadataCache.getFirstLinkpathDest(templatePath, \"\");\n        const contents = await vault.cachedRead(templateFile);\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        const IFoldInfo = window.app.foldManager.load(templateFile);\n        return [contents, IFoldInfo];\n    }\n    catch (err) {\n        console.error(`Failed to read the daily note template '${templatePath}'`, err);\n        new obsidian.Notice(\"Failed to read the daily note template\");\n        return [\"\", null];\n    }\n}\n\n/**\n * dateUID is a way of weekly identifying daily/weekly/monthly notes.\n * They are prefixed with the granularity to avoid ambiguity.\n */\nfunction getDateUID(date, granularity = \"day\") {\n    const ts = date.clone().startOf(granularity).format();\n    return `${granularity}-${ts}`;\n}\nfunction removeEscapedCharacters(format) {\n    return format.replace(/\\[[^\\]]*\\]/g, \"\"); // remove everything within brackets\n}\n/**\n * XXX: When parsing dates that contain both week numbers and months,\n * Moment choses to ignore the week numbers. For the week dateUID, we\n * want the opposite behavior. Strip the MMM from the format to patch.\n */\nfunction isFormatAmbiguous(format, granularity) {\n    if (granularity === \"week\") {\n        const cleanFormat = removeEscapedCharacters(format);\n        return (/w{1,2}/i.test(cleanFormat) &&\n            (/M{1,4}/.test(cleanFormat) || /D{1,4}/.test(cleanFormat)));\n    }\n    return false;\n}\nfunction getDateFromFile(file, granularity) {\n    return getDateFromFilename(file.basename, granularity);\n}\nfunction getDateFromPath(path, granularity) {\n    return getDateFromFilename(basename(path), granularity);\n}\nfunction getDateFromFilename(filename, granularity) {\n    const getSettings = {\n        day: getDailyNoteSettings,\n        week: getWeeklyNoteSettings,\n        month: getMonthlyNoteSettings,\n        quarter: getQuarterlyNoteSettings,\n        year: getYearlyNoteSettings,\n    };\n    const format = getSettings[granularity]().format.split(\"/\").pop();\n    const noteDate = window.moment(filename, format, true);\n    if (!noteDate.isValid()) {\n        return null;\n    }\n    if (isFormatAmbiguous(format, granularity)) {\n        if (granularity === \"week\") {\n            const cleanFormat = removeEscapedCharacters(format);\n            if (/w{1,2}/i.test(cleanFormat)) {\n                return window.moment(filename, \n                // If format contains week, remove day & month formatting\n                format.replace(/M{1,4}/g, \"\").replace(/D{1,4}/g, \"\"), false);\n            }\n        }\n    }\n    return noteDate;\n}\n\nclass DailyNotesFolderMissingError extends Error {\n}\n/**\n * This function mimics the behavior of the daily-notes plugin\n * so it will replace {{date}}, {{title}}, and {{time}} with the\n * formatted timestamp.\n *\n * Note: it has an added bonus that it's not 'today' specific.\n */\nasync function createDailyNote(date) {\n    const app = window.app;\n    const { vault } = app;\n    const moment = window.moment;\n    const { template, format, folder } = getDailyNoteSettings();\n    const [templateContents, IFoldInfo] = await getTemplateInfo(template);\n    const filename = date.format(format);\n    const normalizedPath = await getNotePath(folder, filename);\n    try {\n        const createdFile = await vault.create(normalizedPath, templateContents\n            .replace(/{{\\s*date\\s*}}/gi, filename)\n            .replace(/{{\\s*time\\s*}}/gi, moment().format(\"HH:mm\"))\n            .replace(/{{\\s*title\\s*}}/gi, filename)\n            .replace(/{{\\s*(date|time)\\s*(([+-]\\d+)([yqmwdhs]))?\\s*(:.+?)?}}/gi, (_, _timeOrDate, calc, timeDelta, unit, momentFormat) => {\n            const now = moment();\n            const currentDate = date.clone().set({\n                hour: now.get(\"hour\"),\n                minute: now.get(\"minute\"),\n                second: now.get(\"second\"),\n            });\n            if (calc) {\n                currentDate.add(parseInt(timeDelta, 10), unit);\n            }\n            if (momentFormat) {\n                return currentDate.format(momentFormat.substring(1).trim());\n            }\n            return currentDate.format(format);\n        })\n            .replace(/{{\\s*yesterday\\s*}}/gi, date.clone().subtract(1, \"day\").format(format))\n            .replace(/{{\\s*tomorrow\\s*}}/gi, date.clone().add(1, \"d\").format(format)));\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        app.foldManager.save(createdFile, IFoldInfo);\n        return createdFile;\n    }\n    catch (err) {\n        console.error(`Failed to create file: '${normalizedPath}'`, err);\n        new obsidian.Notice(\"Unable to create new file.\");\n    }\n}\nfunction getDailyNote(date, dailyNotes) {\n    return dailyNotes[getDateUID(date, \"day\")] ?? null;\n}\nfunction getAllDailyNotes() {\n    /**\n     * Find all daily notes in the daily note folder\n     */\n    const { vault } = window.app;\n    const { folder } = getDailyNoteSettings();\n    const dailyNotesFolder = vault.getAbstractFileByPath(obsidian.normalizePath(folder));\n    if (!dailyNotesFolder) {\n        throw new DailyNotesFolderMissingError(\"Failed to find daily notes folder\");\n    }\n    const dailyNotes = {};\n    obsidian.Vault.recurseChildren(dailyNotesFolder, (note) => {\n        if (note instanceof obsidian.TFile) {\n            const date = getDateFromFile(note, \"day\");\n            if (date) {\n                const dateString = getDateUID(date, \"day\");\n                dailyNotes[dateString] = note;\n            }\n        }\n    });\n    return dailyNotes;\n}\n\nclass WeeklyNotesFolderMissingError extends Error {\n}\nfunction getDaysOfWeek() {\n    const { moment } = window;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    let weekStart = moment.localeData()._week.dow;\n    const daysOfWeek = [\n        \"sunday\",\n        \"monday\",\n        \"tuesday\",\n        \"wednesday\",\n        \"thursday\",\n        \"friday\",\n        \"saturday\",\n    ];\n    while (weekStart) {\n        daysOfWeek.push(daysOfWeek.shift());\n        weekStart--;\n    }\n    return daysOfWeek;\n}\nfunction getDayOfWeekNumericalValue(dayOfWeekName) {\n    return getDaysOfWeek().indexOf(dayOfWeekName.toLowerCase());\n}\nasync function createWeeklyNote(date) {\n    const { vault } = window.app;\n    const { template, format, folder } = getWeeklyNoteSettings();\n    const [templateContents, IFoldInfo] = await getTemplateInfo(template);\n    const filename = date.format(format);\n    const normalizedPath = await getNotePath(folder, filename);\n    try {\n        const createdFile = await vault.create(normalizedPath, templateContents\n            .replace(/{{\\s*(date|time)\\s*(([+-]\\d+)([yqmwdhs]))?\\s*(:.+?)?}}/gi, (_, _timeOrDate, calc, timeDelta, unit, momentFormat) => {\n            const now = window.moment();\n            const currentDate = date.clone().set({\n                hour: now.get(\"hour\"),\n                minute: now.get(\"minute\"),\n                second: now.get(\"second\"),\n            });\n            if (calc) {\n                currentDate.add(parseInt(timeDelta, 10), unit);\n            }\n            if (momentFormat) {\n                return currentDate.format(momentFormat.substring(1).trim());\n            }\n            return currentDate.format(format);\n        })\n            .replace(/{{\\s*title\\s*}}/gi, filename)\n            .replace(/{{\\s*time\\s*}}/gi, window.moment().format(\"HH:mm\"))\n            .replace(/{{\\s*(sunday|monday|tuesday|wednesday|thursday|friday|saturday)\\s*:(.*?)}}/gi, (_, dayOfWeek, momentFormat) => {\n            const day = getDayOfWeekNumericalValue(dayOfWeek);\n            return date.weekday(day).format(momentFormat.trim());\n        }));\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        window.app.foldManager.save(createdFile, IFoldInfo);\n        return createdFile;\n    }\n    catch (err) {\n        console.error(`Failed to create file: '${normalizedPath}'`, err);\n        new obsidian.Notice(\"Unable to create new file.\");\n    }\n}\nfunction getWeeklyNote(date, weeklyNotes) {\n    return weeklyNotes[getDateUID(date, \"week\")] ?? null;\n}\nfunction getAllWeeklyNotes() {\n    const weeklyNotes = {};\n    if (!appHasWeeklyNotesPluginLoaded()) {\n        return weeklyNotes;\n    }\n    const { vault } = window.app;\n    const { folder } = getWeeklyNoteSettings();\n    const weeklyNotesFolder = vault.getAbstractFileByPath(obsidian.normalizePath(folder));\n    if (!weeklyNotesFolder) {\n        throw new WeeklyNotesFolderMissingError(\"Failed to find weekly notes folder\");\n    }\n    obsidian.Vault.recurseChildren(weeklyNotesFolder, (note) => {\n        if (note instanceof obsidian.TFile) {\n            const date = getDateFromFile(note, \"week\");\n            if (date) {\n                const dateString = getDateUID(date, \"week\");\n                weeklyNotes[dateString] = note;\n            }\n        }\n    });\n    return weeklyNotes;\n}\n\nclass MonthlyNotesFolderMissingError extends Error {\n}\n/**\n * This function mimics the behavior of the daily-notes plugin\n * so it will replace {{date}}, {{title}}, and {{time}} with the\n * formatted timestamp.\n *\n * Note: it has an added bonus that it's not 'today' specific.\n */\nasync function createMonthlyNote(date) {\n    const { vault } = window.app;\n    const { template, format, folder } = getMonthlyNoteSettings();\n    const [templateContents, IFoldInfo] = await getTemplateInfo(template);\n    const filename = date.format(format);\n    const normalizedPath = await getNotePath(folder, filename);\n    try {\n        const createdFile = await vault.create(normalizedPath, templateContents\n            .replace(/{{\\s*(date|time)\\s*(([+-]\\d+)([yqmwdhs]))?\\s*(:.+?)?}}/gi, (_, _timeOrDate, calc, timeDelta, unit, momentFormat) => {\n            const now = window.moment();\n            const currentDate = date.clone().set({\n                hour: now.get(\"hour\"),\n                minute: now.get(\"minute\"),\n                second: now.get(\"second\"),\n            });\n            if (calc) {\n                currentDate.add(parseInt(timeDelta, 10), unit);\n            }\n            if (momentFormat) {\n                return currentDate.format(momentFormat.substring(1).trim());\n            }\n            return currentDate.format(format);\n        })\n            .replace(/{{\\s*date\\s*}}/gi, filename)\n            .replace(/{{\\s*time\\s*}}/gi, window.moment().format(\"HH:mm\"))\n            .replace(/{{\\s*title\\s*}}/gi, filename));\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        window.app.foldManager.save(createdFile, IFoldInfo);\n        return createdFile;\n    }\n    catch (err) {\n        console.error(`Failed to create file: '${normalizedPath}'`, err);\n        new obsidian.Notice(\"Unable to create new file.\");\n    }\n}\nfunction getMonthlyNote(date, monthlyNotes) {\n    return monthlyNotes[getDateUID(date, \"month\")] ?? null;\n}\nfunction getAllMonthlyNotes() {\n    const monthlyNotes = {};\n    if (!appHasMonthlyNotesPluginLoaded()) {\n        return monthlyNotes;\n    }\n    const { vault } = window.app;\n    const { folder } = getMonthlyNoteSettings();\n    const monthlyNotesFolder = vault.getAbstractFileByPath(obsidian.normalizePath(folder));\n    if (!monthlyNotesFolder) {\n        throw new MonthlyNotesFolderMissingError(\"Failed to find monthly notes folder\");\n    }\n    obsidian.Vault.recurseChildren(monthlyNotesFolder, (note) => {\n        if (note instanceof obsidian.TFile) {\n            const date = getDateFromFile(note, \"month\");\n            if (date) {\n                const dateString = getDateUID(date, \"month\");\n                monthlyNotes[dateString] = note;\n            }\n        }\n    });\n    return monthlyNotes;\n}\n\nclass QuarterlyNotesFolderMissingError extends Error {\n}\n/**\n * This function mimics the behavior of the daily-notes plugin\n * so it will replace {{date}}, {{title}}, and {{time}} with the\n * formatted timestamp.\n *\n * Note: it has an added bonus that it's not 'today' specific.\n */\nasync function createQuarterlyNote(date) {\n    const { vault } = window.app;\n    const { template, format, folder } = getQuarterlyNoteSettings();\n    const [templateContents, IFoldInfo] = await getTemplateInfo(template);\n    const filename = date.format(format);\n    const normalizedPath = await getNotePath(folder, filename);\n    try {\n        const createdFile = await vault.create(normalizedPath, templateContents\n            .replace(/{{\\s*(date|time)\\s*(([+-]\\d+)([yqmwdhs]))?\\s*(:.+?)?}}/gi, (_, _timeOrDate, calc, timeDelta, unit, momentFormat) => {\n            const now = window.moment();\n            const currentDate = date.clone().set({\n                hour: now.get(\"hour\"),\n                minute: now.get(\"minute\"),\n                second: now.get(\"second\"),\n            });\n            if (calc) {\n                currentDate.add(parseInt(timeDelta, 10), unit);\n            }\n            if (momentFormat) {\n                return currentDate.format(momentFormat.substring(1).trim());\n            }\n            return currentDate.format(format);\n        })\n            .replace(/{{\\s*date\\s*}}/gi, filename)\n            .replace(/{{\\s*time\\s*}}/gi, window.moment().format(\"HH:mm\"))\n            .replace(/{{\\s*title\\s*}}/gi, filename));\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        window.app.foldManager.save(createdFile, IFoldInfo);\n        return createdFile;\n    }\n    catch (err) {\n        console.error(`Failed to create file: '${normalizedPath}'`, err);\n        new obsidian.Notice(\"Unable to create new file.\");\n    }\n}\nfunction getQuarterlyNote(date, quarterly) {\n    return quarterly[getDateUID(date, \"quarter\")] ?? null;\n}\nfunction getAllQuarterlyNotes() {\n    const quarterly = {};\n    if (!appHasQuarterlyNotesPluginLoaded()) {\n        return quarterly;\n    }\n    const { vault } = window.app;\n    const { folder } = getQuarterlyNoteSettings();\n    const quarterlyFolder = vault.getAbstractFileByPath(obsidian.normalizePath(folder));\n    if (!quarterlyFolder) {\n        throw new QuarterlyNotesFolderMissingError(\"Failed to find quarterly notes folder\");\n    }\n    obsidian.Vault.recurseChildren(quarterlyFolder, (note) => {\n        if (note instanceof obsidian.TFile) {\n            const date = getDateFromFile(note, \"quarter\");\n            if (date) {\n                const dateString = getDateUID(date, \"quarter\");\n                quarterly[dateString] = note;\n            }\n        }\n    });\n    return quarterly;\n}\n\nclass YearlyNotesFolderMissingError extends Error {\n}\n/**\n * This function mimics the behavior of the daily-notes plugin\n * so it will replace {{date}}, {{title}}, and {{time}} with the\n * formatted timestamp.\n *\n * Note: it has an added bonus that it's not 'today' specific.\n */\nasync function createYearlyNote(date) {\n    const { vault } = window.app;\n    const { template, format, folder } = getYearlyNoteSettings();\n    const [templateContents, IFoldInfo] = await getTemplateInfo(template);\n    const filename = date.format(format);\n    const normalizedPath = await getNotePath(folder, filename);\n    try {\n        const createdFile = await vault.create(normalizedPath, templateContents\n            .replace(/{{\\s*(date|time)\\s*(([+-]\\d+)([yqmwdhs]))?\\s*(:.+?)?}}/gi, (_, _timeOrDate, calc, timeDelta, unit, momentFormat) => {\n            const now = window.moment();\n            const currentDate = date.clone().set({\n                hour: now.get(\"hour\"),\n                minute: now.get(\"minute\"),\n                second: now.get(\"second\"),\n            });\n            if (calc) {\n                currentDate.add(parseInt(timeDelta, 10), unit);\n            }\n            if (momentFormat) {\n                return currentDate.format(momentFormat.substring(1).trim());\n            }\n            return currentDate.format(format);\n        })\n            .replace(/{{\\s*date\\s*}}/gi, filename)\n            .replace(/{{\\s*time\\s*}}/gi, window.moment().format(\"HH:mm\"))\n            .replace(/{{\\s*title\\s*}}/gi, filename));\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        window.app.foldManager.save(createdFile, IFoldInfo);\n        return createdFile;\n    }\n    catch (err) {\n        console.error(`Failed to create file: '${normalizedPath}'`, err);\n        new obsidian.Notice(\"Unable to create new file.\");\n    }\n}\nfunction getYearlyNote(date, yearlyNotes) {\n    return yearlyNotes[getDateUID(date, \"year\")] ?? null;\n}\nfunction getAllYearlyNotes() {\n    const yearlyNotes = {};\n    if (!appHasYearlyNotesPluginLoaded()) {\n        return yearlyNotes;\n    }\n    const { vault } = window.app;\n    const { folder } = getYearlyNoteSettings();\n    const yearlyNotesFolder = vault.getAbstractFileByPath(obsidian.normalizePath(folder));\n    if (!yearlyNotesFolder) {\n        throw new YearlyNotesFolderMissingError(\"Failed to find yearly notes folder\");\n    }\n    obsidian.Vault.recurseChildren(yearlyNotesFolder, (note) => {\n        if (note instanceof obsidian.TFile) {\n            const date = getDateFromFile(note, \"year\");\n            if (date) {\n                const dateString = getDateUID(date, \"year\");\n                yearlyNotes[dateString] = note;\n            }\n        }\n    });\n    return yearlyNotes;\n}\n\nfunction appHasDailyNotesPluginLoaded() {\n    const { app } = window;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const dailyNotesPlugin = app.internalPlugins.plugins[\"daily-notes\"];\n    if (dailyNotesPlugin && dailyNotesPlugin.enabled) {\n        return true;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const periodicNotes = app.plugins.getPlugin(\"periodic-notes\");\n    return periodicNotes && periodicNotes.settings?.daily?.enabled;\n}\n/**\n * XXX: \"Weekly Notes\" live in either the Calendar plugin or the periodic-notes plugin.\n * Check both until the weekly notes feature is removed from the Calendar plugin.\n */\nfunction appHasWeeklyNotesPluginLoaded() {\n    const { app } = window;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    if (app.plugins.getPlugin(\"calendar\")) {\n        return true;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const periodicNotes = app.plugins.getPlugin(\"periodic-notes\");\n    return periodicNotes && periodicNotes.settings?.weekly?.enabled;\n}\nfunction appHasMonthlyNotesPluginLoaded() {\n    const { app } = window;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const periodicNotes = app.plugins.getPlugin(\"periodic-notes\");\n    return periodicNotes && periodicNotes.settings?.monthly?.enabled;\n}\nfunction appHasQuarterlyNotesPluginLoaded() {\n    const { app } = window;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const periodicNotes = app.plugins.getPlugin(\"periodic-notes\");\n    return periodicNotes && periodicNotes.settings?.quarterly?.enabled;\n}\nfunction appHasYearlyNotesPluginLoaded() {\n    const { app } = window;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const periodicNotes = app.plugins.getPlugin(\"periodic-notes\");\n    return periodicNotes && periodicNotes.settings?.yearly?.enabled;\n}\nfunction getPeriodicNoteSettings(granularity) {\n    const getSettings = {\n        day: getDailyNoteSettings,\n        week: getWeeklyNoteSettings,\n        month: getMonthlyNoteSettings,\n        quarter: getQuarterlyNoteSettings,\n        year: getYearlyNoteSettings,\n    }[granularity];\n    return getSettings();\n}\nfunction createPeriodicNote(granularity, date) {\n    const createFn = {\n        day: createDailyNote,\n        month: createMonthlyNote,\n        week: createWeeklyNote,\n    };\n    return createFn[granularity](date);\n}\n\nexports.DEFAULT_DAILY_NOTE_FORMAT = DEFAULT_DAILY_NOTE_FORMAT;\nexports.DEFAULT_MONTHLY_NOTE_FORMAT = DEFAULT_MONTHLY_NOTE_FORMAT;\nexports.DEFAULT_QUARTERLY_NOTE_FORMAT = DEFAULT_QUARTERLY_NOTE_FORMAT;\nexports.DEFAULT_WEEKLY_NOTE_FORMAT = DEFAULT_WEEKLY_NOTE_FORMAT;\nexports.DEFAULT_YEARLY_NOTE_FORMAT = DEFAULT_YEARLY_NOTE_FORMAT;\nexports.appHasDailyNotesPluginLoaded = appHasDailyNotesPluginLoaded;\nexports.appHasMonthlyNotesPluginLoaded = appHasMonthlyNotesPluginLoaded;\nexports.appHasQuarterlyNotesPluginLoaded = appHasQuarterlyNotesPluginLoaded;\nexports.appHasWeeklyNotesPluginLoaded = appHasWeeklyNotesPluginLoaded;\nexports.appHasYearlyNotesPluginLoaded = appHasYearlyNotesPluginLoaded;\nexports.createDailyNote = createDailyNote;\nexports.createMonthlyNote = createMonthlyNote;\nexports.createPeriodicNote = createPeriodicNote;\nexports.createQuarterlyNote = createQuarterlyNote;\nexports.createWeeklyNote = createWeeklyNote;\nexports.createYearlyNote = createYearlyNote;\nexports.getAllDailyNotes = getAllDailyNotes;\nexports.getAllMonthlyNotes = getAllMonthlyNotes;\nexports.getAllQuarterlyNotes = getAllQuarterlyNotes;\nexports.getAllWeeklyNotes = getAllWeeklyNotes;\nexports.getAllYearlyNotes = getAllYearlyNotes;\nexports.getDailyNote = getDailyNote;\nexports.getDailyNoteSettings = getDailyNoteSettings;\nexports.getDateFromFile = getDateFromFile;\nexports.getDateFromPath = getDateFromPath;\nexports.getDateUID = getDateUID;\nexports.getMonthlyNote = getMonthlyNote;\nexports.getMonthlyNoteSettings = getMonthlyNoteSettings;\nexports.getPeriodicNoteSettings = getPeriodicNoteSettings;\nexports.getQuarterlyNote = getQuarterlyNote;\nexports.getQuarterlyNoteSettings = getQuarterlyNoteSettings;\nexports.getTemplateInfo = getTemplateInfo;\nexports.getWeeklyNote = getWeeklyNote;\nexports.getWeeklyNoteSettings = getWeeklyNoteSettings;\nexports.getYearlyNote = getYearlyNote;\nexports.getYearlyNoteSettings = getYearlyNoteSettings;\n","import { App, Notice, Plugin, PluginSettingTab, Setting, moment, MarkdownView } from 'obsidian';\r\nimport { createDailyNote, getAllDailyNotes, getDailyNote } from 'obsidian-daily-notes-interface';\r\n\r\ninterface LumberjackSettings {\r\n\tlogPrefix: string;\r\n\tuseTimestamp: boolean;\r\n\talwaysOpenInNewLeaf: boolean;\r\n\tinboxFilePath: string;\r\n\tnewDraftFilenameTemplate: string;\r\n\ttargetHeader: string;\r\n\ttimestampFormat: string;\r\n}\r\n\r\nconst DEFAULT_SETTINGS: LumberjackSettings = {\r\n\tlogPrefix: '- [ ] ',\r\n\tuseTimestamp: true,\r\n\talwaysOpenInNewLeaf: false,\r\n\tinboxFilePath: \"Inbox\",\r\n\tnewDraftFilenameTemplate: \"YYYYMMDDHHmmss\",\r\n\ttargetHeader: \"Journal\",\r\n\ttimestampFormat: \"HH:mm\"\r\n}\r\n\r\nconst editModeState = {\r\n\tstate: { mode: \"source\" },\r\n\tactive: true,\r\n\tfocus: true\r\n};\r\n\r\ninterface Parameters {\r\n\tdata?: string;\r\n\tvault?: string;\r\n\tname?: string;\r\n}\r\n\r\nexport default class LumberjackPlugin extends Plugin {\r\n\tsettings: LumberjackSettings;\r\n\r\n\tasync onload() {\r\n\t\tconsole.debug('Loading the Lumberjack plugin. 𖥧');\r\n\r\n\t\tawait this.loadSettings();\r\n\r\n\t\tthis.addCommand({\r\n\t\t\tid: 'lumberjack-log',\r\n\t\t\tname: 'Log something new on your daily note',\r\n\t\t\tcallback: () => {\r\n\t\t\t\tthis.newLog(this.settings.alwaysOpenInNewLeaf);\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\tthis.addSettingTab(new LumberjackSettingsTab(this.app, this));\r\n\r\n\t\tthis.registerObsidianProtocolHandler(\"log\", async (𖣂) => {\r\n\r\n\t\t\t// Need to handle multiple vaults, I guess. Sigh.\r\n\r\n\t\t\tconst parameters = 𖣂 as unknown as Parameters;\r\n\r\n\t\t\tfor (const parameter in parameters) { // not yet using parameters\r\n\t\t\t\t(parameters as any)[parameter] = (parameters as any)[parameter]; // Thanks to @Vinzent03 for a clear-cut (pun intended) example of how to do this\r\n\t\t\t}\r\n\r\n\t\t\tthis.newLog(this.settings.alwaysOpenInNewLeaf);\r\n\t\t});\r\n\r\n\t\tthis.registerObsidianProtocolHandler(\"timber\", async (𖣂) => {\r\n\r\n\t\t\t// Need to handle multiple vaults, I guess. Sigh.\r\n\r\n\t\t\tconst parameters = 𖣂 as unknown as Parameters;\r\n\r\n\t\t\tfor (const parameter in parameters) { // not yet actually using parameters\r\n\t\t\t\t(parameters as any)[parameter] = (parameters as any)[parameter]; // Thanks to @Vinzent03 for a clear-cut (pun intended) example of how to do this\r\n\t\t\t}\r\n\r\n\t\t\tif (parameters.name) {\r\n\t\t\t\t// this.ifATreeFallsInTheBackgroundDidItEverReallyFall(parameters.name); // not yet implemented\r\n\t\t\t} else {\r\n\t\t\t\tthis.timber();\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t}\r\n\r\n\t// newLog creates a new item with a user-configured prefix under a user-configured heading in the daily note, and gives them editing ability in that position immediately.\r\n\tasync newLog(openFileInNewLeaf: boolean) {\r\n\r\n\t\t// find or create the daily note\r\n\t\tlet dailyNote = getDailyNote(moment(), getAllDailyNotes());\r\n\t\tif (!dailyNote) { dailyNote = await createDailyNote(moment()); }\r\n\t\t\r\n\t\t// set up the timestamp string, if the user is using it\r\n\t\tlet tampTime: string;\r\n\t\tif (this.settings.useTimestamp) {\r\n\t\t\ttampTime = moment().format(this.settings.timestampFormat) + \" \";\r\n\t\t} else {\r\n\t\t\ttampTime = \"\";\r\n\t\t}\r\n\r\n\t\t// open the daily note in edit mode and get the editor\r\n\t\tlet openedDailyNote = await this.app.workspace.openLinkText(dailyNote.name, dailyNote.path, openFileInNewLeaf, editModeState);\r\n\t\tif (this.app.workspace.getActiveViewOfType(MarkdownView)) {\r\n\t\t\tlet editor = this.app.workspace.getActiveViewOfType(MarkdownView).editor;\r\n\t\t\tif (editor == null) {\r\n\t\t\t\tnew Notice(`Could not find the daily note. Check your daily note settings, or report this as a bug on the plugin repository.`);\r\n\t\t\t\treturn\r\n\t\t\t}\r\n\r\n\r\n\t\t\t// establish the line prefix to add, if anything\r\n\t\t\tlet linePrefix = `\r\n${this.settings.logPrefix}${tampTime}`\r\n\r\n\t\t\t// Make sure the editor has focus\r\n\t\t\teditor.focus();\r\n\r\n\t\t\t// Inserting the cursor\r\n\t\t\t// The goal is to set the cursor either at the end of the user's target section, if set, or at the end of the note\r\n\t\t\t\r\n\t\t\t// find the section to insert the log item into and set the insert position to append into it, or set the insert position to the end of the note\r\n\t\t\tlet sections = this.app.metadataCache.getFileCache(dailyNote).headings;\r\n\t\t\tif (!sections) {\r\n\t\t\t\t// The daily note does not have sections. Insert the log item at the bottom of the note.\r\n\t\t\t\teditor.setCursor(editor.lastLine());\r\n\t\t\t\teditor.replaceSelection(linePrefix);\r\n\t\t\t\teditor.setCursor(editor.lastLine());\r\n\t\t\t} else {\r\n\t\t\t\tif (this.settings.targetHeader != \"\") { // If the user has set a target header\r\n\t\t\t\t\t// need to figure out which line the _next_ section is on, if any, then use that line number in the functions below\r\n\t\t\t\t\tlet targetSection = sections.find( (eachSection) => (eachSection.heading == this.settings.targetHeader)); // does the heading we're looking for exist?\r\n\t\t\t\t\tif (targetSection) { // The target section exists\r\n\t\t\t\t\t\tlet nextSection = sections.find( (eachSection) => ((eachSection.position.start.line > targetSection.position.start.line) && (eachSection.level <= targetSection.level))); // matches sections _after_ our target, with the same level or greater\r\n\t\t\t\t\t\tconsole.debug(nextSection);\r\n\t\t\t\t\t\tif (!nextSection) {\r\n\t\t\t\t\t\t\t// There is no section following the target section. Look for the end of the document\r\n\t\t\t\t\t\t\t// A better approach would append the item at the end of the content inside the user's target section, because it's possible that someone would put more stuff in their daily note without a following section, but that will have to be implemented later.\r\n\t\t\t\t\t\t\tconsole.debug(\"No section follows the target section. Inserting the log item at the end of the target section.\")\r\n\t\t\t\t\t\t\teditor.setCursor(editor.lastLine());\r\n\t\t\t\t\t\t\teditor.replaceSelection(linePrefix);\r\n\t\t\t\t\t\t\teditor.setCursor(editor.lastLine());\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\tif (typeof(nextSection) !== undefined) { // The search for a following section did not return undefined, therefore it exists\r\n\t\t\t\t\t\t\t\t// Find out if there is a preceding blank line before the next section. E.g., does the user use linebreaks to separate content in edit mode? If so, inserting the next item after that line break will look messy.\r\n\t\t\t\t\t\t\t\t\r\n\t\t\t\t\t\t\t\tif (editor.getLine(nextSection.position.start.line - 1) === editor.getLine(targetSection.position.start.line)) {\r\n\t\t\t\t\t\t\t\t\t// There are no lines between the next section and the target section. Insert the log item immediately after the target section.\r\n\t\t\t\t\t\t\t\t\teditor.setCursor(nextSection.position.start.line - 1);\r\n\t\t\t\t\t\t\t\t\teditor.replaceSelection(linePrefix);\r\n\t\t\t\t\t\t\t\t\teditor.setCursor(nextSection.position.start.line);\r\n\t\t\t\t\t\t\t\t} else if (editor.getLine(nextSection.position.start.line - 1).length > 0) {\r\n\t\t\t\t\t\t\t\t\t// The line just before the next section header is not blank. Insert the log item just before the next section, without a line break.\r\n\t\t\t\t\t\t\t\t\tconsole.debug(\"No blank lines found between the target section and the next section.\");\r\n\t\t\t\t\t\t\t\t\teditor.setCursor(nextSection.position.start.line - 2);\r\n\t\t\t\t\t\t\t\t\teditor.replaceSelection(linePrefix);\r\n\t\t\t\t\t\t\t\t\teditor.setCursor(nextSection.position.start.line);\r\n\t\t\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\t\t\tconsole.debug(`The line before the next section has 0 length. It is line number: ${nextSection.position.start.line - 1}`)\r\n\t\t\t\t\t\t\t\t\t// The line just before the next section header is blank. It's likely that the user uses line breaks to clean up their note in edit mode. \r\n\t\t\t\t\t\t\t\t\t// The approach here is to iterate over the lines preceding the next section header until a non-blank line is reached, then insert the log item at (iterator.position.start.line + 1)...\r\n\t\t\t\t\t\t\t\t\tlet lastBlankLineFound = false;\r\n\t\t\t\t\t\t\t\t\tlet noBlankLines = false;\r\n\t\t\t\t\t\t\t\t\tlet lastLineBeforeLineBreakIteratorLineNumber = nextSection.position.start.line - 1; // `lastLineBeforeLineBreakIteratorNumber: this wordy variable represents the number of the last-line-before-line-break iterator's current line\r\n\t\t\t\t\t\t\t\t\twhile (lastBlankLineFound == false) {\r\n\t\t\t\t\t\t\t\t\t\tif (lastLineBeforeLineBreakIteratorLineNumber == 0) { // This condition would mean the iterator found the start of the document\r\n\t\t\t\t\t\t\t\t\t\t\tnoBlankLines = true;\r\n\t\t\t\t\t\t\t\t\t\t\tlastBlankLineFound = true;\r\n\t\t\t\t\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\t\t\t\t\tlet blankLineFinderCurrentLine = editor.getLine(lastLineBeforeLineBreakIteratorLineNumber);\r\n\t\t\t\t\t\t\t\t\t\t\tif (blankLineFinderCurrentLine.toString() === \"\") {\r\n\t\t\t\t\t\t\t\t\t\t\t\tlastBlankLineFound = true;\r\n\t\t\t\t\t\t\t\t\t\t\t\tconsole.debug(\"found the last line\");\r\n\t\t\t\t\t\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\t\t\t\t\t\tlastLineBeforeLineBreakIteratorLineNumber = lastLineBeforeLineBreakIteratorLineNumber - 1; // Move to the next line up\r\n\t\t\t\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t\t\t}\r\n\t\r\n\t\t\t\t\t\t\t\t\tif (noBlankLines) { // this means the iterator failed to find any blanks at all; insert the log item just before the next section.\r\n\t\t\t\t\t\t\t\t\t\tconsole.debug(\"No blank lines found.\");\r\n\t\t\t\t\t\t\t\t\t\teditor.setCursor(nextSection.position.start.line - 1);\r\n\t\t\t\t\t\t\t\t\t\teditor.replaceSelection(linePrefix);\r\n\t\t\t\t\t\t\t\t\t\teditor.setCursor(nextSection.position.start.line - 1);\r\n\t\t\t\t\t\t\t\t\t} else { // There were an arbitrary number of blank lines before the next section header. Insert the log item _after_ the last (length > 0) line before the next section header.\r\n\t\t\t\t\t\t\t\t\t\tconsole.debug(`Iterator stopped at line ${lastLineBeforeLineBreakIteratorLineNumber}, with text ${editor.getLine(lastLineBeforeLineBreakIteratorLineNumber)}`);\r\n\t\t\t\t\t\t\t\t\t\teditor.setCursor(lastLineBeforeLineBreakIteratorLineNumber - 1);\r\n\t\t\t\t\t\t\t\t\t\teditor.replaceSelection(linePrefix);\r\n\t\t\t\t\t\t\t\t\t\teditor.setCursor(lastLineBeforeLineBreakIteratorLineNumber);\r\n\t\t\t\t\t\t\t\t\t}\r\n\t\r\n\t\t\t\t\t\t\t\t\t\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tnew Notice(`Could not run the Log command. Your daily note does not contain the target section you've specified in Preferences → Lumberjack—that is, the heading \"${this.settings.targetHeader}\". Please enter a heading that exists in your daily note, or leave this setting blank.`);\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\t\t\t\t} else {\r\n\t\t\t\t\t// The user has not set a target header. Insert the log item at the bottom of the note.\r\n\t\t\t\t\teditor.setCursor(editor.lastLine());\r\n\t\t\t\t\teditor.replaceSelection(linePrefix);\r\n\t\t\t\t\teditor.setCursor(editor.lastLine());\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t}\r\n\r\n\t\r\n\t}\r\n\r\n// \t// Log the thought in the background.\r\n//\t// Not yet implemented.\r\n// \tasync ifATreeFallsInTheBackgroundDidItEverReallyFall(someData: string) {\r\n// \t\tlet dailyNote = getDailyNote(moment(), getAllDailyNotes());\r\n// \t\tif (!dailyNote) { dailyNote = await createDailyNote(moment()); }\r\n// \t\tlet tampTime: string;\r\n\t\t\r\n// \t\tif (this.settings.useTimestamp) {\r\n// \t\t\ttampTime = moment().format(\"HH:mm\") + \" \";\r\n// \t\t}\r\n\r\n// \t\tlet dailyNoteOldText = await this.app.vault.read(dailyNote); // unsure about using .read versus .cachedRead here. as this is meant to be used when Obsidian is in the background\r\n\r\n// \t\tlet dailyNoteNewText = `${dailyNoteOldText}\r\n// ${this.settings.logPrefix}${tampTime}${someData}`\r\n\r\n// \t\tthis.app.vault.modify(dailyNote, dailyNoteNewText) // write the new line in\r\n// \t\tnew Notice('Data \"' + someData + '\" logged to the daily note.');\r\n// \t}\r\n\r\n\tasync timber() {\r\n\r\n\t\tlet zkUUIDNoteName = moment().format(this.settings.newDraftFilenameTemplate);\r\n\t\tconst isInboxPathEmpty = this.settings.inboxFilePath === undefined || this.settings.inboxFilePath.trim() === '';\r\n\t\tconst folderName = isInboxPathEmpty ? '' : this.settings.inboxFilePath;\r\n\t\tconst inboxPath = isInboxPathEmpty ? '' : `/${this.settings.inboxFilePath}/`;\r\n\r\n\t\tconsole.debug(`${this.settings.inboxFilePath}`);\r\n\r\n\t\tif (!isInboxPathEmpty && !(this.app.vault.getAbstractFileByPath(`${folderName}`))) { // In the future, handle folder creation as necessary. For now, error and tell the user if the inbox folder does not exist.\r\n\t\t\tnew Notice(`Error. Lumberjack couldn't create the draft. Does the inbox folder you've set in Preferences -> Lumberjack 🪓🪵 exist?`);\r\n\t\t\treturn;\r\n\t\t}\r\n\t\t\r\n\t\tawait this.app.vault.create(`${inboxPath}${zkUUIDNoteName}.md`, \"\");\r\n\r\n\t\tlet newDraft = await this.app.workspace.openLinkText(zkUUIDNoteName, `${inboxPath}`, this.settings.alwaysOpenInNewLeaf, editModeState);\r\n\r\n\t\tif (this.app.workspace.getActiveViewOfType(MarkdownView)) {\r\n\t\t\tlet editor = this.app.workspace.getActiveViewOfType(MarkdownView).editor;\r\n\t\t\tif (editor == null) {\r\n\t\t\t\tnew Notice(`Couldn't run the Timber command. Please report this as a bug in the GitHub repository for Lumberjack 🪓🪵`);\r\n\t\t\t\treturn\r\n\t\t\t}\r\n\r\n\t\t\teditor.focus();\r\n\t\t\tlet startChar = \"\";\r\n\t\t\teditor.setCursor(editor.lastLine());\r\n\t\t\teditor.replaceSelection(startChar);\r\n\t\t\teditor.setCursor(editor.lastLine());\r\n\t\t}\r\n\r\n\t}\r\n\r\n\tonunload() {\r\n\t\tconsole.debug('Unloading the Lumberjack plugin. Watch out for splinters.');\r\n\t}\r\n\r\n\tasync loadSettings() {\r\n\t\tthis.settings = Object.assign({}, DEFAULT_SETTINGS, 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\r\nclass LumberjackSettingsTab extends PluginSettingTab {\r\n\tplugin: LumberjackPlugin;\r\n\r\n\tconstructor(app: App, plugin: LumberjackPlugin) {\r\n\t\tsuper(app, plugin);\r\n\t\tthis.plugin = plugin;\r\n\t}\r\n\r\n\tdisplay(): void {\r\n\t\tlet {containerEl} = this;\r\n\r\n\t\tcontainerEl.empty();\r\n\r\n\t\tcontainerEl.createEl('h2', {text: 'Lumberjack Settings'});\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Target header')\r\n\t\t\t.setDesc('Append logged items to a target header in your daily note')\r\n\t\t\t.addText(text => text\r\n\t\t\t\t.setPlaceholder(this.plugin.settings.targetHeader)\r\n\t\t\t\t.setValue(this.plugin.settings.targetHeader)\r\n\t\t\t\t.onChange(async (value) => {\r\n\t\t\t\t\tthis.plugin.settings.targetHeader = value;\r\n\t\t\t\t\tawait this.plugin.saveSettings();\r\n\t\t\t\t}));\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Prefix for logging')\r\n\t\t\t.setDesc('Sets a prefix for lines added via the log command')\r\n\t\t\t.addText(text => text\r\n\t\t\t\t.setPlaceholder('Prefix:')\r\n\t\t\t\t.setValue(this.plugin.settings.logPrefix)\r\n\t\t\t\t.onChange(async (value) => {\r\n\t\t\t\t\tthis.plugin.settings.logPrefix = value;\r\n\t\t\t\t\tawait this.plugin.saveSettings();\r\n\t\t\t\t}));\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Timestamp')\r\n\t\t\t.setDesc('If enabled, the log command will prefix newly added lines with a timestamp. (Changing this setting reloads the plugin.)')\r\n\t\t\t.addToggle(toggle => toggle\r\n\t\t\t\t.setValue(this.plugin.settings.useTimestamp)\r\n\t\t\t\t.onChange(async (value) => {\r\n\t\t\t\t\tthis.plugin.settings.useTimestamp = value;\r\n\t\t\t\t\tawait this.plugin.saveSettings();\r\n\t\t\t\t\tif (value) {\r\n\t\t\t\t\t\tthis.containerEl.appendChild(timestampFormatSetting.settingEl);\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\ttimestampFormatSetting.settingEl.remove();\r\n\t\t\t\t\t}\r\n\t\t\t\t}));\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Always open in a new pane')\r\n\t\t\t.setDesc('If enabled, Lumberjack commands will always open in a new pane.')\r\n\t\t\t.addToggle(toggle => toggle\r\n\t\t\t\t.setValue(this.plugin.settings.alwaysOpenInNewLeaf)\r\n\t\t\t\t.onChange(async (value) => {\r\n\t\t\t\t\tthis.plugin.settings.alwaysOpenInNewLeaf = value;\r\n\t\t\t\t\tawait this.plugin.saveSettings();\r\n\t\t\t\t}));\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Inbox folder')\r\n\t\t\t.setDesc('Set the destination for notes created with `obsidian://timber`, e.g., `My Notes/Inbox`. Do not include leading or trailing slashes.')\r\n\t\t\t.addText(text => text\r\n\t\t\t\t.setValue(this.plugin.settings.inboxFilePath)\r\n\t\t\t\t.setPlaceholder(this.plugin.settings.inboxFilePath)\r\n\t\t\t\t.onChange(async (value) => {\r\n\t\t\t\t\tthis.plugin.settings.inboxFilePath = value;\r\n\t\t\t\t\tawait this.plugin.saveSettings();\r\n\t\t\t\t}));\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Filename for new drafts')\r\n\t\t\t.setDesc('Set the filename template for new drafts created with `obsidian://timber`. Uses Moment formatting, same as daily notes. Default: YYYYMMDDHHmm')\r\n\t\t\t.addText(text => text\r\n\t\t\t\t.setValue(this.plugin.settings.newDraftFilenameTemplate)\r\n\t\t\t\t.setPlaceholder(this.plugin.settings.newDraftFilenameTemplate)\r\n\t\t\t\t.onChange(async (value) => {\r\n\t\t\t\t\tthis.plugin.settings.newDraftFilenameTemplate = value;\r\n\t\t\t\t\tawait this.plugin.saveSettings();\r\n\t\t\t\t}));\r\n\t\tlet timestampFormatSetting = new Setting(containerEl)\r\n\t\t\t.setName('Timestamp format')\r\n\t\t\t.setDesc('Set the format for timestamp prefixes. Follows Moment.js formatting, same as Obsidian\\'s core daily notes.')\r\n\t\t\t.addText(text => text\r\n\t\t\t\t.setValue(this.plugin.settings.timestampFormat)\r\n\t\t\t\t.setPlaceholder(this.plugin.settings.timestampFormat)\r\n\t\t\t\t.onChange(async (value) => {\r\n\t\t\t\t\tthis.plugin.settings.timestampFormat = value;\r\n\t\t\t\t\tawait this.plugin.saveSettings();\r\n\t\t\t\t}))\r\n\r\n\t\tif (!this.plugin.settings.useTimestamp) {\r\n\t\t\ttimestampFormatSetting.settingEl.remove();\r\n\t\t}\r\n\t}\r\n}\r\n"],"names":["obsidian","Plugin","getDailyNote","moment","getAllDailyNotes","createDailyNote","MarkdownView","Notice","PluginSettingTab","Setting"],"mappings":"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"} diff --git a/.obsidian/plugins/lumberjack-obsidian/manifest.json b/.obsidian/plugins/lumberjack-obsidian/manifest.json new file mode 100644 index 0000000..a8eb458 --- /dev/null +++ b/.obsidian/plugins/lumberjack-obsidian/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "lumberjack-obsidian", + "name": "Lumberjack 🪓 🪵", + "version": "1.3.0", + "minAppVersion": "0.12.0", + "description": "Log your thoughts! Lumberjack adds URL commands to help you axe inefficiency and get right to writing.", + "author": "ryanjamurphy", + "authorUrl": "https://axle.design", + "isDesktopOnly": false +} diff --git a/.obsidian/plugins/recent-files-obsidian/data.json b/.obsidian/plugins/recent-files-obsidian/data.json index da2d365..e4a572a 100644 --- a/.obsidian/plugins/recent-files-obsidian/data.json +++ b/.obsidian/plugins/recent-files-obsidian/data.json @@ -4,6 +4,22 @@ "basename": "README", "path": "README.md" }, + { + "basename": "Smartphone Capture", + "path": "Inbox/Smartphone Capture/Smartphone Capture.md" + }, + { + "basename": "Inbox", + "path": "Inbox/Inbox.md" + }, + { + "basename": "_tutorial", + "path": "_tutorial/_tutorial.md" + }, + { + "basename": "To Process", + "path": "Computed/To Process.md" + }, { "basename": "Test Project", "path": "_PARA/Projects/Test Project/Test Project.md" @@ -12,10 +28,6 @@ "basename": "_PARA", "path": "_PARA/_PARA.md" }, - { - "basename": "Inbox", - "path": "Inbox/Inbox.md" - }, { "basename": "Scratchpad", "path": "Inbox/Scratchpad.md" @@ -40,14 +52,6 @@ "basename": "Tasks", "path": "Computed/Tasks.md" }, - { - "basename": "To Process", - "path": "Computed/To Process.md" - }, - { - "basename": "_tutorial", - "path": "_tutorial/_tutorial.md" - }, { "basename": "2022-12-11--12-00-00", "path": "Inbox/Computer Capture/2022-12-11--12-00-00.md" @@ -195,10 +199,6 @@ { "basename": "seinfeld the art of seduction", "path": "Private/Attachments/seinfeld the art of seduction.png" - }, - { - "basename": "Attachments", - "path": "Attachments/Attachments.md" } ], "omittedPaths": [], diff --git a/.obsidian/workspace.json b/.obsidian/workspace.json index 86e4cf3..631cb6b 100644 --- a/.obsidian/workspace.json +++ b/.obsidian/workspace.json @@ -27,7 +27,7 @@ "state": { "type": "markdown", "state": { - "file": "_PARA/Projects/Test Project/Test Project.md", + "file": "Inbox/Smartphone Capture/Smartphone Capture.md", "mode": "source", "source": false } @@ -206,17 +206,17 @@ "periodic-notes:Open today": false } }, - "active": "c102a50492c64997", + "active": "fa7779fed8ad75a1", "lastOpenFiles": [ + "Inbox/Smartphone Capture/Smartphone Capture.md", + "Inbox/Inbox.md", + "_tutorial/_tutorial.md", + "Computed/To Process.md", + "README.md", "_PARA/Projects/Test Project/Test Project.md", "_PARA/_PARA.md", - "README.md", - "Inbox/Inbox.md", "Inbox/Scratchpad.md", "Private/Secret Note.md", - "Computed/CRM.md", - "_tutorial/Hotkeys.md", - "Computed/Trackers.md", - "Computed/Tasks.md" + "Computed/CRM.md" ] } \ No newline at end of file diff --git a/README.md b/README.md index 86761d8..678b81a 100644 --- a/README.md +++ b/README.md @@ -707,6 +707,8 @@ The following is a list of these plugins as well as a one sentence blurb of how - Full calendar is a full calendar in obsidian. Full calendar allows you to connect notes to independent meetings and events in your schedule - [New Tab Default Page](obsidian://show-plugin?id=new-tab-default-page) - new tab default page is what happens when you hit the plus button on the tab bar you can choose to open a random note a daily note or anything in between +- [Lumberjack](obsidian://show-plugin?id=lumberjack-obsidian) + - lumber jack is a plug-in that allows you to log to your daily note a pending after the journal header or use the timber obsidian URL to append an out directly to your inbox - [Plugin Update Tracker](obsidian://show-plugin?id=obsidian-plugin-update-tracker) - plug-in update tracker keeps track of plug-ins that you've installed and let you know when they need updating it also tells you what is in there Changelog so you can see the code that changed - [GPT-3 Summarizer](https://github.com/bramses/summarize-with-gpt3-obsidian)