From 0f02f07359d34a604500a9ac7dbf3c876bcce59e Mon Sep 17 00:00:00 2001 From: moremeyou Date: Thu, 12 Oct 2023 21:02:26 +0200 Subject: [PATCH] 0.5.0 --- manifest.json | 2 +- src/main.js | 1790 +++++++++++++++++++++++++++++++++++++++++++++ src/package.json | 2 +- src/versions.json | 5 + versions.json | 4 - 5 files changed, 1797 insertions(+), 6 deletions(-) create mode 100644 src/main.js create mode 100644 src/versions.json delete mode 100644 versions.json diff --git a/manifest.json b/manifest.json index 7622b88..e0bccca 100644 --- a/manifest.json +++ b/manifest.json @@ -1,7 +1,7 @@ { "id": "tag-buddy", "name": "Tag Buddy", - "version": "0.3.0", + "version": "0.5.0", "minAppVersion": "1.0.0", "description": "Add, edit and remove tags and copy, move or edit tagged blocks all without leaving reading-mode.", "author": "David Fasullo", diff --git a/src/main.js b/src/main.js new file mode 100644 index 0000000..4cccfee --- /dev/null +++ b/src/main.js @@ -0,0 +1,1790 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ESBUILD +if you want to view the source, please visit the github repository of this plugin +*/ + +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// main.ts +var main_exports = {}; +__export(main_exports, { + default: () => TagBuddy +}); +module.exports = __toCommonJS(main_exports); + +// settings.ts +var import_obsidian = require("obsidian"); +var TBSettingsTab = class extends import_obsidian.PluginSettingTab { + constructor(app2, plugin) { + super(app2, plugin); + this.plugin = plugin; + } + display() { + let { containerEl } = this; + containerEl.empty(); + containerEl.createEl("h1", { text: "Tag Buddy" }); + new import_obsidian.Setting(containerEl).setName("Override native tag search on click").setDesc("Toggle OFF to use CTRL/CMD+CLICK to remove tag.").addToggle( + (toggle) => toggle.setValue(this.plugin.settings.removeOnClick).onChange(async (value) => { + this.plugin.settings.removeOnClick = value; + await this.plugin.saveSettings(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Convert to tag text (removes #)").setDesc("Toggle OFF to use OPT/ALT+CLICK to perform native tag search.").addToggle( + (toggle) => toggle.setValue(this.plugin.settings.optToConvert).onChange(async (value) => { + this.plugin.settings.optToConvert = value; + await this.plugin.saveSettings(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Remove nested tags first").setDesc("Toggle OFF to use SHIFT+CLICK to remove nested tags first.").addToggle( + (toggle) => toggle.setValue(this.plugin.settings.removeChildTagsFirst).onChange(async (value) => { + this.plugin.settings.removeChildTagsFirst = value; + await this.plugin.saveSettings(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Mobile tag search").setDesc("Toggle ON to restore mobile native tag search on tap. Tag removal will then use LONG PRESS.").addToggle( + (toggle) => toggle.setValue(this.plugin.settings.mobileTagSearch).onChange(async (value) => { + this.plugin.settings.mobileTagSearch = value; + await this.plugin.saveSettings(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Show mobile notices").setDesc("Toggle OFF to hide notices when editing or removing a tag.").addToggle( + (toggle) => toggle.setValue(this.plugin.settings.mobileNotices).onChange(async (value) => { + this.plugin.settings.mobileNotices = value; + await this.plugin.saveSettings(); + }) + ); + new import_obsidian.Setting(containerEl).setName("BETA: Show tag summary paragraph buttons").setDesc("Show buttons below each tagged paragraph that let you copy, remove, and move the paragraph.").addToggle( + (toggle) => toggle.setValue(this.plugin.settings.tagSummaryBlockButtons).onChange(async (value) => { + this.plugin.settings.tagSummaryBlockButtons = value; + await this.plugin.saveSettings(); + }) + ); + new import_obsidian.Setting(containerEl).setName("BETA: Show tag summary buttons").setDesc("Show buttons below each summary that let you copy or make a note from the summary.").addToggle( + (toggle) => toggle.setValue(this.plugin.settings.showSummaryButtons).onChange(async (value) => { + this.plugin.settings.showSummaryButtons = value; + await this.plugin.saveSettings(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Copy to section prefix").setDesc("When moving a tagged paragraph from tag summaries below note header sections use this prefix:\nExample: '- ', '> ', '- [ ]'").addText((text) => { + text.setPlaceholder(this.plugin.settings.taggedParagraphCopyPrefix).setValue(this.plugin.settings.taggedParagraphCopyPrefix).onChange(async (value) => { + this.plugin.settings.taggedParagraphCopyPrefix = value; + await this.plugin.saveSettings(); + }); + }); + function isValidTag(tag) { + const tagPattern = /^#[\w]+$/; + return tagPattern.test(tag); + } + function filterAndJoinTags(tagsString) { + const tagsArray = tagsString.split(", "); + const validTags = tagsArray.filter(isValidTag); + return validTags.join(", "); + } + new import_obsidian.Setting(containerEl).setName("Recent tags").setDesc("The most recent tags added via Tag Buddy are stored here. These will show up first in the list when adding.").addText((text) => { + text.setPlaceholder(this.plugin.settings.recentlyAddedTags).setValue(this.plugin.settings.recentlyAddedTags).onChange(async (value) => { + this.plugin.settings.recentlyAddedTags = filterAndJoinTags(value); + await this.plugin.saveSettings(); + }); + }); + new import_obsidian.Setting(containerEl).setName("Lock recent tags").setDesc("Toggle ON to lock the recent tags list. Recent tags will not be updated. Instead, the tags above will act like a favorites list.").addToggle( + (toggle) => toggle.setValue(this.plugin.settings.lockRecentTags).onChange(async (value) => { + this.plugin.settings.lockRecentTags = value; + await this.plugin.saveSettings(); + }) + ); + containerEl.createEl("hr"); + containerEl.createEl("h1", { text: "Support a buddy" }); + const donateButton = containerEl.createEl("a"); + donateButton.setAttribute("href", "https://www.buymeacoffee.com/moremeyou"); + donateButton.innerHTML = `Buy Me A Coffee`; + containerEl.createEl("br"); + containerEl.createEl("br"); + containerEl.createEl("br"); + new import_obsidian.Setting(containerEl).setName("Debug mode").setDesc("Output to console.").addToggle( + (toggle) => toggle.setValue(this.plugin.settings.debugMode).onChange(async (value) => { + this.plugin.settings.debugMode = value; + await this.plugin.saveSettings(); + }) + ); + } +}; + +// main.ts +var import_obsidian2 = require("obsidian"); +var DEFAULT_SETTINGS = { + removeOnClick: true, + // when true, cmd is needed when clicking to remove the tag + removeChildTagsFirst: true, + // use shift when false + optToConvert: true, + // when false, clicking tag will do nothing + mobileTagSearch: false, + // toggle on use double tap for search. press+hold will then remove. + mobileNotices: true, + tagSummaryBlockButtons: false, + taggedParagraphCopyPrefix: "", + recentlyAddedTags: "", + lockRecentTags: false, + showSummaryButtons: false, + debugMode: false +}; +var TagBuddy = class extends import_obsidian2.Plugin { + onunload() { + } + async onload() { + await this.loadSettings(); + this.addSettingTab(new TBSettingsTab(this.app, this)); + console.log("Tag Buddy Plugin loaded on " + (this.app.isMobile ? "mobile at " : "desktop at ") + new Date().toUTCString().substring(17)); + this.injectStyles(); + const debouncedProcessTags = this.debounce(this.processTags.bind(this), 500); + this.app.workspace.onLayoutReady(async () => { + setTimeout(async () => { + this.processTags(); + }, 500); + this.registerEvent(this.app.workspace.on("active-leaf-change", async () => { + })); + this.registerDomEvent(document, "contextmenu", async (event) => { + const view = await this.app.workspace.getActiveViewOfType(import_obsidian2.MarkdownView); + if (view && this.ctrlCmdKey(event) && view.getMode() == "preview") { + event.preventDefault(); + const file = await this.app.workspace.getActiveFile(); + this.showTagSelector(event.pageX, event.pageY, file); + } + }); + this.registerEvent(this.app.on("layout-change", (event) => { + debouncedProcessTags(); + })); + this.registerEvent(this.app.on("file-open", async (event) => { + debouncedProcessTags(); + })); + if (!this.app.isMobile) { + this.registerDomEvent(document, "click", this.onClickEvent.bind(this), true); + } else { + this.registerDomEvent(document, "click", (e) => { + const isTag = e.target.classList.contains("tag"); + if (isTag && !this.settings.mobileTagSearch) { + e.stopPropagation(); + } + }, true); + new PressAndHoldHandler(this, document, this.onClickEvent.bind(this)); + new DoubleTapHandler(this, document, this.onClickEvent.bind(this)); + } + }); + this.registerMarkdownCodeBlockProcessor("tag-summary", this.summaryCodeBlockProcessor.bind(this)); + } + async onClickEvent(event) { + const target = event.target; + const view = await this.app.workspace.getActiveViewOfType(import_obsidian2.MarkdownView); + if (!view && target.matches(".tag")) { + new import_obsidian2.Notice("Tag Buddy: Can't edit tag. Unsupported view type. Try again within that note."); + return; + } + if (view) { + if (view.getMode() != "preview") + return; + } else { + } + if (!this.app.isMobile) { + if (this.settings.removeOnClick && this.ctrlCmdKey(event) || !this.settings.removeOnClick && !this.ctrlCmdKey(event)) { + return; + } else if (event.altKey && !this.settings.optToConvert) { + return; + } + } else { + if (this.settings.mobileTagSearch && event.type == "touchend") { + return; + } + } + if (target && target.matches(".tag")) { + if (this.settings.removeOnClick || !this.settings.removeOnClick && this.ctrlCmdKey(event)) { + event.stopPropagation(); + event.preventDefault(); + } + const clickedTag = target.closest(".tag"); + const tag = clickedTag.innerText; + let tagIndex = clickedTag.getAttribute("md-index"); + let tagFile = clickedTag.getAttribute("file-source"); + if (tagFile) { + this.editTag(target, event); + } else { + setTimeout(async () => { + tagIndex = clickedTag.getAttribute("md-index"); + tagFile = clickedTag.getAttribute("file-source"); + this.editTag(target, event); + }, 300); + } + } else if (!view && target.matches(".tag")) { + new import_obsidian2.Notice("Tag Buddy: Can't edit tag. Might be in an unsupported view type."); + } + } + async editTag(tagEl, event, pragraphEl) { + const index = tagEl.getAttribute("md-index"); + const filePath = tagEl.getAttribute("file-source"); + if (this.settings.debugMode) + console.log("Tag Buddy edit tag: " + tagEl.innerText + "\nIn file: " + filePath); + if (filePath) { + const file = await this.validateFilePath(filePath); + let fileContent; + let fileContentBackup; + const tag = tagEl.innerText.trim(); + try { + fileContent = await this.app.vault.read(file); + fileContentBackup = fileContent; + } catch (error) { + new import_obsidian2.Notice("Tag Buddy file read error:\n" + error.message); + return; + } + let safeToEmptyFile = false; + const tagRegex = /^\s*#(\w+)\s*$/; + if (tagRegex.test(fileContent.trim())) { + safeToEmptyFile = true; + } + let beforeTag = fileContent.substring(0, index); + let afterTag = fileContent.substring(Number(index) + Number(tag.length)); + let afterTagChr; + let beforeTagChr; + if (afterTag.startsWith(" ")) { + afterTagChr = " "; + } else if (afterTag.startsWith("\n")) { + afterTagChr = "\n"; + } + if (fileContent[index] === "\n") { + beforeTag += "\n"; + } + let newContent = ""; + if (!event) { + newContent = beforeTag + afterTagChr + afterTag; + } else if (event.altKey || event.type == "touchstart" && !this.settings.mobileTagSearch) { + const noHash = tag.substring(1); + newContent = beforeTag + noHash + afterTagChr + afterTag; + if (this.app.isMobile && this.settings.mobileNotices) { + new import_obsidian2.Notice("Tag Buddy: " + tag + " converted to text."); + } + } else if (event.type == "touchend" || this.settings.mobileTagSearch || this.ctrlCmdKey(event) && !this.settings.removeOnClick || !this.ctrlCmdKey(event) && this.settings.removeOnClick) { + let parentTag = ""; + if (tag.includes("/") && (this.settings.removeChildTagsFirst || event.shiftKey && !this.settings.removeChildTagsFirst)) { + let parts = tag.split("/"); + const removedChild = parts.pop(); + parentTag = parts.join("/"); + newContent = beforeTag + (!beforeTag.endsWith(" ") ? " " : "") + parentTag + afterTagChr + afterTag; + if (this.app.isMobile && this.settings.mobileNotices) { + new import_obsidian2.Notice("Tag Buddy: '" + removedChild + "' removed from parent tag."); + } + } else { + newContent = beforeTag + afterTag; + if (this.app.isMobile && this.settings.mobileNotices) { + new import_obsidian2.Notice("Tag Buddy: " + tag + " removed."); + } + } + } + try { + if (tagEl.getAttribute("type") == "plugin-summary") { + const summaryEl = tagEl.closest(".tag-summary-paragraph"); + const mdSource = summaryEl.getAttribute("md-source").trim(); + const escapedText = this.escapeRegExp(mdSource); + const regex = new RegExp(escapedText, "g"); + const matches = fileContent.match(regex); + if (matches && matches.length > 1) { + new import_obsidian2.Notice("\u26A0\uFE0F Can't safely remove/edit tag:\nSurrounding text repeated in source note."); + return; + } else if (matches && matches.length === 0 || !matches) { + new import_obsidian2.Notice("\u26A0\uFE0F Can't find tag in source note.\n"); + return; + } + if (newContent == "" && !safeToEmptyFile || this.contentChangedTooMuch(fileContentBackup, newContent, tag, 2)) { + new import_obsidian2.Notice("Tag Buddy: File change error."); + newContent = fileContentBackup; + } else if (newContent == "" && safeToEmptyFile) { + new import_obsidian2.Notice("Tag Buddy: Tag removed. The note is empty."); + } + setTimeout(async () => { + const tagParagraphEl = tagEl.closest(".tag-summary-paragraph"); + const tagSummaryBlock = tagEl.closest(".tag-summary-block"); + const tagsToCheck = this.getTagsToCheckFromEl(tagSummaryBlock); + const tagsInContent = this.tagsInString(tagParagraphEl.innerText); + if (tagsToCheck.includes(tag)) { + const tagCount = this.countOccurrences(tagsToCheck, tagsInContent); + if (tagCount >= 2) { + this.updateSummary(tagSummaryBlock); + setTimeout(async () => { + this.processTags(); + }, 200); + } else { + const notice = new import_obsidian2.Notice(tag + " removed from paragraph.\n\u{1F517} Open source note.", 5e3); + this.removeElementWithAnimation(tagParagraphEl, () => { + setTimeout(async () => { + this.updateSummary(tagSummaryBlock); + tagParagraphEl.remove(); + }, 500); + setTimeout(async () => { + this.processTags(); + }, 800); + }); + this.registerDomEvent(notice.noticeEl, "click", (e) => { + this.app.workspace.openLinkText(filePath, ""); + }); + } + } else { + this.updateSummary(tagSummaryBlock); + setTimeout(async () => { + this.processTags(); + }, 200); + } + }, 200); + } else { + setTimeout(async () => { + this.processTags(); + }, 50); + } + await this.app.vault.modify(file, newContent); + } catch (error) { + try { + const backupFileName = String(file.name.substring(0, file.name.indexOf(".md")) + " BACKUP.md"); + this.app.vault.create(backupFileName, fileContentBackup); + new import_obsidian2.Notice("\u26A0\uFE0F Tag/note editing error: " + error.message + "\n" + backupFileName + " saved to vault root."); + } catch (error2) { + navigator.clipboard.writeText(fileContentBackup); + new import_obsidian2.Notice("\u26A0\uFE0F Tag/note editing error: " + error2.message + "\nNote content copied to clipboard."); + } + } + } else { + this.processTags(); + new import_obsidian2.Notice("\u26A0\uFE0F Can't identify tag location. Please try again."); + } + } + getTagsToCheckFromEl(tagSummaryEl) { + const tagsStr = tagSummaryEl.getAttribute("codeblock-tags"); + const tags = tagsStr ? tagsStr.split(",") : []; + const tagsIncludeStr = tagSummaryEl.getAttribute("codeblock-tags-include"); + const tagsInclude = tagsIncludeStr ? tagsIncludeStr.split(",") : []; + return tags.concat(tagsInclude); + } + updateSummary(summaryEl) { + const summaryContainer = summaryEl; + const tagsStr = summaryContainer.getAttribute("codeblock-tags"); + const tags = tagsStr ? tagsStr.split(",") : []; + const tagsIncludeStr = summaryContainer.getAttribute("codeblock-tags-include"); + const tagsInclude = tagsIncludeStr ? tagsIncludeStr.split(",") : []; + const tagsExcludeStr = summaryContainer.getAttribute("codeblock-tags-exclude"); + const tagsExclude = tagsExcludeStr ? tagsExcludeStr.split(",") : []; + const sectionsStr = summaryContainer.getAttribute("codeblock-sections"); + const sections = sectionsStr ? sectionsStr.split(",") : []; + const max = Number(summaryContainer.getAttribute("codeblock-max")); + const mdSource = summaryContainer.getAttribute("codeblock-code"); + this.createSummary(summaryContainer, tags, tagsInclude, tagsExclude, sections, max, "", mdSource); + } + /*async updateSummariess () { + //const activeFile = await this.app.workspace.getActiveFile(); + //const fileContent = await app.vault.read(activeFile); + const activeNoteContainer = await this.app.workspace.activeLeaf.containerEl; + const embeds = await activeNoteContainer.querySelectorAll('.tag-summary-block'); + //let embededTagFiles = []; + + embeds.forEach(async (embed) => { + if (embed.classList.contains('tag-summary-block')) { + this.updateSummary (embed); + } + }); + }*/ + async processTags() { + if (this.settings.debugMode) + console.log("Tag Buddy: Processing tags."); + const view = await this.app.workspace.getActiveViewOfType(import_obsidian2.MarkdownView); + if (view) { + const activeNoteContainer = await this.app.workspace.activeLeaf.containerEl; + const activeNoteReadingView = activeNoteContainer.querySelector(".markdown-reading-view"); + const activeNoteEditView = activeNoteContainer.querySelector(".markdown-source-view"); + const activeFile = await this.app.workspace.getActiveFile(); + const fileContent = await app.vault.read(activeFile); + const activeFileTagElements = await activeNoteContainer.querySelectorAll(".mod-active .tag:not(.markdown-embed .tag):not(.tag-summary-block .tag)"); + const activeFileTags = await this.getMarkdownTags(activeFile, fileContent); + if (activeFileTags.length > 0) + this.assignMarkdownTags(activeFileTags, activeFileTagElements, 0, "active"); + this.processEmbeds(activeNoteReadingView); + } + } + async getMarkdownTags(file, fileContent) { + const tagPositions = []; + let match; + const regex = /(?<=^|\s)(#[^\s#.,;!?:]+)(?=[.,;!?:\s]|$)|```/g; + let insideCodeBlock = false; + while ((match = regex.exec(fileContent)) !== null) { + if (match[0].trim() === "```") { + insideCodeBlock = !insideCodeBlock; + continue; + } + if (insideCodeBlock) + continue; + const tag = match[0].trim(); + if (fileContent.slice(match.index, match.index + tag.length + 2).endsWith("]]")) { + continue; + } + tagPositions.push({ tag, index: match.index, source: file.name }); + } + return tagPositions; + } + assignMarkdownTags(tagPositions, tagElements, startIndex, type) { + let tagEl; + const tagElArray = Array.from(tagElements); + let tagElIndex = 0; + tagPositions.forEach((tagPos, i) => { + if (tagPositions[i].index >= startIndex) { + tagEl = tagElArray[tagElIndex]; + if (tagEl) { + tagEl.setAttribute("md-index", tagPositions[i].index); + tagEl.setAttribute("file-source", tagPositions[i].source); + tagEl.setAttribute("type", type); + } + tagElIndex++; + } + }); + return tagElArray; + } + async processEmbeds(element, ids = ["tag-summary-block", "markdown-embed"]) { + const embeds = await element.querySelectorAll(".tag-summary-block, .markdown-embed"); + embeds.forEach(async (embed) => { + if (embed.classList.contains("tag-summary-block")) { + this.processTagSummary(embed); + } else if (embed.classList.contains("markdown-embed")) { + this.processNativeEmbed(embed); + if (Array.from(embed.querySelectorAll(".tag-summary-block")).length > 0) { + this.processTagSummary(embed); + } + } else { + } + }); + } + async processNativeEmbed(embed) { + const linkElement = embed.getAttribute("src"); + let filePath = embed.getAttribute("src"); + const linkArray = filePath.split("#"); + filePath = linkArray[0].trim() + ".md"; + const file = await this.validateFilePath(filePath); + if (file) { + const fileContent = await app.vault.read(file); + const embededTagFile = await this.getMarkdownTags(file, fileContent); + const tempComponent = new TempComponent(); + const tempContainerHTML = createEl("div"); + await import_obsidian2.MarkdownRenderer.renderMarkdown(fileContent, tempContainerHTML, file.path, tempComponent); + const innerText = embed.querySelector(".markdown-embed-content").innerText; + const startIndex = tempContainerHTML.innerText.indexOf(innerText); + this.assignMarkdownTags(embededTagFile, embed.querySelectorAll(".tag"), startIndex, "native-embed"); + } + } + async processTagSummary(embed) { + let summaryBlocks = embed.querySelectorAll("blockquote"); + summaryBlocks.forEach(async (block, index) => { + var _a, _b; + const filePath = block.getAttribute("file-source"); + const file = this.app.vault.getAbstractFileByPath(filePath); + const tempComponent = new TempComponent(); + if (file) { + let fileContent = await app.vault.read(file); + const embededTagFile = await this.getMarkdownTags(file, fileContent); + const tempBlock = block.cloneNode(true); + (_a = tempBlock.querySelector(".tagsummary-item-title")) == null ? void 0 : _a.remove(); + (_b = tempBlock.querySelector(".tagsummary-buttons")) == null ? void 0 : _b.remove(); + const markdownBlock = block.getAttribute("md-source").trim(); + const startIndex = fileContent.indexOf(markdownBlock); + this.assignMarkdownTags(embededTagFile, block.querySelectorAll(".tag"), startIndex, "plugin-summary"); + } + }); + } + async summaryCodeBlockProcessor(source, el, ctx) { + let tags = Array(); + let include = Array(); + let exclude = Array(); + let sections = Array(); + let max = 50; + const maxPattern = /^\s*max:\s*(\d+)\s*$/; + let match; + const rows = source.split("\n").filter((row) => row.length > 0); + rows.forEach((line) => { + if (line.match(/^\s*tags:[\p{L}0-9_\-/# ]+$/gu)) { + const content = line.replace(/^\s*tags:/, "").trim(); + let list = content.split(/\s+/).map((tag) => tag.trim()); + list = list.filter((tag) => { + if (tag.match(/^#[\p{L}]+[^#]*$/u)) { + return true; + } else { + return false; + } + }); + tags = list; + } + if (line.match(/^\s*include:[\p{L}0-9_\-/# ]+$/gu)) { + const content = line.replace(/^\s*include:/, "").trim(); + let list = content.split(/\s+/).map((tag) => tag.trim()); + list = list.filter((tag) => { + if (tag.match(/^#[\p{L}]+[^#]*$/u)) { + return true; + } else { + return false; + } + }); + include = list; + } + if (line.match(/^\s*exclude:[\p{L}0-9_\-/# ]+$/gu)) { + const content = line.replace(/^\s*exclude:/, "").trim(); + let list = content.split(/\s+/).map((tag) => tag.trim()); + list = list.filter((tag) => { + if (tag.match(/^#[\p{L}]+[^#]*$/u)) { + return true; + } else { + return false; + } + }); + exclude = list; + } + if (line.match(/^\s*sections:[\p{L}0-9_\-/#, ]+$/gu)) { + const content = line.replace(/^\s*sections:/, "").trim(); + let list = content.split(",").map((sec) => sec.trim()); + sections = list; + } + match = line.match(maxPattern); + if (match) { + max = Math.min(50, Number(match[1])); + } + }); + const codeBlock = "```tag-summary\n" + source.trim() + "\n```"; + if (tags.length > 0 || include.length > 0) { + await this.createSummary(el, tags, include, exclude, sections, max, ctx.sourcePath, codeBlock); + } else { + this.createEmptySummary(el, tags ? tags : [], include ? include : [], exclude ? exclude : [], sections ? sections : [], max ? max : [], ctx.sourcePath ? ctx.sourcePath : "", codeBlock); + } + } + createEmptySummary(element, tags, include, exclude, sections, max, fileCtx, mdSource) { + const container = createEl("div"); + const textDiv = createEl("blockquote"); + textDiv.innerHTML = "There are no files with tagged paragraphs that match the tags:
" + (tags.length > 0 ? tags.join(", ") : "No tags specified.") + "
"; + container.appendChild(textDiv); + container.setAttribute("codeblock-tags", tags.length > 0 ? tags.join(",") : ""); + container.setAttribute("codeblock-tags-include", include ? include.join(",") : ""); + container.setAttribute("codeblock-tags-exclude", exclude ? exclude.join(",") : ""); + container.setAttribute("codeblock-sections", sections ? sections.join(",") : ""); + container.setAttribute("codeblock-max", max); + container.setAttribute("codeblock-code", mdSource); + container.appendChild(this.makeSummaryRefreshButton(container)); + ; + element.replaceWith(container); + } + async createSummary(element, tags, include, exclude, sections, max, fileCtx, mdSource) { + const activeFile = await this.app.workspace.getActiveFile(); + const validTags = tags.concat(include); + const tempComponent = new TempComponent(); + const summaryContainer = createEl("div"); + summaryContainer.setAttribute("class", "tag-summary-block"); + let listFiles = this.app.vault.getMarkdownFiles(); + listFiles = listFiles.filter((file) => { + const cache = app.metadataCache.getFileCache(file); + const tagsInFile = (0, import_obsidian2.getAllTags)(cache); + if (validTags.some((value) => tagsInFile.includes(value))) { + return true; + } + return false; + }); + listFiles = listFiles.sort((file1, file2) => { + if (file1.path < file2.path) { + return -1; + } else if (file1.path > file2.path) { + return 1; + } else { + return 0; + } + }); + let listContents = await this.readFiles(listFiles); + let count = 0; + let summary = ""; + listContents.forEach((item) => { + const fileName = item[0].name.replace(/.md$/g, ""); + const filePath = item[0].path; + if (activeFile) { + if (activeFile.name == item[0].name) + return; + } + let listParagraphs = Array(); + const blocks = item[1].split(/\n\s*\n/).filter((row) => row.trim().length > 0); + blocks.forEach((paragraph) => { + let valid = false; + let listTags = paragraph.match(/#[\p{L}0-9_\-/#]+/gu); + if (listTags != null && listTags.length > 0) { + if (!paragraph.contains("```")) { + valid = this.isValidText(listTags, tags, include, exclude); + } + } + if (valid) { + let listItems = Array(); + let itemText = ""; + paragraph.split("\ns*\n").forEach((line) => { + if (count >= max) + return; + let isList = false; + isList = line.search(/(\s*[\-\+\*]){1}|([0-9]\.){1}\s+/) != -1; + if (!isList) { + listParagraphs.push(line); + itemText = ""; + } else { + line.split("\n").forEach((itemLine) => { + let level = 0; + const endIndex = itemLine.search(/[\-\+\*]{1}|([0-9]\.){1}\s+/); + const tabText = itemLine.slice(0, endIndex); + const tabs = tabText.match(/\t/g); + if (tabs) { + level = tabs.length; + } + if (level == 0) { + if (itemText != "") { + listItems.push(itemText); + itemText = ""; + } + itemText = "" + itemText.concat(itemLine + "\n"); + } else if (level > 0 && itemText != "") { + itemText = itemText.concat(itemLine + "\n"); + } + }); + } + count++; + }); + if (itemText != "") { + listItems.push(itemText); + itemText = ""; + } + listItems.forEach((line) => { + listTags = line.match(/#[\p{L}0-9_\-/#]+/gu); + if (listTags != null && listTags.length > 0) { + if (this.isValidText(listTags, tags, include, exclude)) { + listParagraphs.push(line); + } + } + }); + } + }); + listParagraphs.forEach(async (paragraph) => { + paragraph += "\n"; + var regex = new RegExp(); + var tagText = new String(); + var tagSection = null; + tags.forEach((tag) => { + tagText = tag.replace("#", "\\#"); + regex = new RegExp(`${tagText}(\\W|$)`, "g"); + if (paragraph.match(regex) != null) { + tagSection = tag; + } + }); + const buttonContainer = createEl("div"); + buttonContainer.setAttribute("class", "tagsummary-buttons"); + const paragraphEl = createEl("blockquote"); + paragraphEl.setAttribute("file-source", filePath); + paragraphEl.setAttribute("class", "tag-summary-paragraph"); + const blockLink = paragraph.match(/\^[\p{L}0-9_\-/^]+/gu); + let link; + if (blockLink) { + link = "[[" + filePath + "#" + blockLink + "|" + fileName + "]]"; + let count2 = 0; + sections.forEach((sec) => { + if (count2++ > 3) + return; + buttonContainer.appendChild(this.makeCopyToButton(paragraph, sec, paragraphEl, tags, filePath + "#" + blockLink, paragraphEl, summaryContainer)); + }); + if (this.settings.tagSummaryBlockButtons) { + buttonContainer.appendChild(this.makeCopyButton(paragraph.trim())); + buttonContainer.appendChild(this.makeRemoveTagButton(paragraphEl, tagSection, filePath + "#" + blockLink)); + } + } else { + link = "[[" + filePath + "|" + fileName + "]]"; + let count2 = 0; + sections.forEach((sec) => { + if (count2++ > 3) + return; + if (this.settings.tagSummaryBlockButtons) + buttonContainer.appendChild(this.makeCopyToButton(paragraph, sec, paragraphEl, tags, filePath, paragraphEl, summaryContainer)); + }); + if (this.settings.tagSummaryBlockButtons) { + buttonContainer.appendChild(this.makeCopyButton(paragraph.trim())); + buttonContainer.appendChild(this.makeRemoveTagButton(paragraphEl, tagSection, filePath)); + } + } + const mdParagraph = paragraph; + paragraph = "**" + link + "**\n" + paragraph; + summary += paragraph + "\n"; + await import_obsidian2.MarkdownRenderer.renderMarkdown(paragraph, paragraphEl, "", tempComponent); + const titleEl = createEl("span"); + titleEl.setAttribute("class", "tagsummary-item-title"); + titleEl.appendChild(paragraphEl.querySelector("strong").cloneNode(true)); + if (this.settings.tagSummaryBlockButtons) + paragraphEl.appendChild(buttonContainer); + paragraphEl.querySelector("strong").replaceWith(titleEl); + paragraphEl.setAttribute("md-source", mdParagraph); + summaryContainer.appendChild(paragraphEl); + }); + }); + if (summary != "") { + setTimeout(async () => { + if (this.settings.showSummaryButtons) { + summaryContainer.appendChild(this.makeSummaryRefreshButton(summaryContainer)); + summaryContainer.appendChild(this.makeCopySummaryButton(summary)); + summaryContainer.appendChild(this.makeSummaryNoteButton(summary, tags)); + summaryContainer.appendChild(this.makeBakeButton(summary, summaryContainer, activeFile.path)); + summaryContainer.appendChild(createEl("br")); + } + summaryContainer.appendChild(createEl("hr")); + }, 0); + summaryContainer.setAttribute("codeblock-tags", tags.join(",")); + summaryContainer.setAttribute("codeblock-tags-include", include.length > 0 ? include.join(",") : ""); + summaryContainer.setAttribute("codeblock-tags-exclude", exclude.length > 0 ? exclude.join(",") : ""); + summaryContainer.setAttribute("codeblock-sections", sections.length > 0 ? sections.join(",") : ""); + summaryContainer.setAttribute("codeblock-max", max); + summaryContainer.setAttribute("codeblock-code", mdSource); + element.replaceWith(summaryContainer); + } else { + this.createEmptySummary(element, tags ? tags : [], include ? include : [], exclude ? exclude : [], sections ? sections : [], max ? max : [], "", mdSource); + } + } + /*makeSwitchToEditingButton (view){ + const button = this.makeButton ('Edit code block in edit-mode', async(e) => { + e.stopPropagation(); + const view = await this.app.workspace.getActiveViewOfType(MarkdownView); + if (view.getMode() == 'preview') { + let curState = view.getState(); + curState.mode = 'source'; + view.setState(curState); + } + }); + button.title = 'Switch to edit mode'; + return button; + }*/ + makeCopySummaryButton(summaryMd) { + const button = this.makeButton(" \u274F ", (e) => { + e.stopPropagation(); + navigator.clipboard.writeText(summaryMd); + new import_obsidian2.Notice("Summary copied to clipboard."); + }); + button.title = "Copy summary"; + return button; + } + makeSummaryNoteButton(summaryMd, tags) { + const button = this.makeButton("Note", (e) => { + e.stopPropagation(); + const newNoteObj = this.fileObjFromTags(tags); + let fileContent = "## " + newNoteObj.title + "\n\n" + summaryMd; + const fileName = this.getActiveFileFolder() + newNoteObj.fileName; + const file = this.app.vault.getAbstractFileByPath(fileName); + let notice; + tags.forEach((tag) => { + fileContent = this.replaceTextInString(tag, fileContent, tag.substring(1), true); + }); + if (file instanceof import_obsidian2.TFile) { + notice = new import_obsidian2.Notice("\u26A0\uFE0F Note already exists.\nClick here to overwrite.", 5e3); + this.registerDomEvent(notice.noticeEl, "click", (e2) => { + this.app.vault.modify(file, fileContent); + notice = new import_obsidian2.Notice("Note updated.\n\u{1F517} Open note.", 5e3); + this.registerDomEvent(notice.noticeEl, "click", (e3) => { + this.app.workspace.openLinkText(fileName, ""); + }); + }); + } else if (!file) { + this.app.vault.create(fileName, fileContent); + const notice2 = new import_obsidian2.Notice("Tag Buddy: Summary note created. \u{1F4DC}\n\u{1F517} Open note."); + this.registerDomEvent(notice2.noticeEl, "click", (e2) => { + this.app.workspace.openLinkText(newNoteObj.fileName, ""); + }); + } + }); + button.title = "Create note from summary"; + return button; + } + fileObjFromTags(tags) { + let tagsArray = tags.map((tag) => tag.replace(/#/g, "").toLowerCase()); + tagsArray = tagsArray.filter((tag, index, self) => self.indexOf(tag) === index); + const tagsPart = tagsArray.join("+"); + const currentDate = new Date(); + const datePart = currentDate.getDate().toString().padStart(2, "0") + "-" + (currentDate.getMonth() + 1).toString().padStart(2, "0") + "-" + currentDate.getFullYear().toString().slice(-2); + const fileName = `Tag Summary (${tagsPart}) (${datePart}).md`; + const titleTagsPart = tagsArray.map((tag) => tag.charAt(0).toUpperCase() + tag.slice(1)).join(" + "); + const title = `${titleTagsPart} Tag Summary`; + return { + fileName, + title + }; + } + getActiveFileFolder() { + const activeFile = app.workspace.activeLeaf.view.file; + if (!activeFile) + return null; + const pathSeparator = activeFile.path.includes("\\") ? "\\" : "/"; + const pathParts = activeFile.path.split(pathSeparator); + pathParts.pop(); + let folderPath = pathParts.join(pathSeparator); + if (!folderPath.endsWith(pathSeparator)) { + folderPath += pathSeparator; + } + return folderPath; + } + makeSummaryRefreshButton(summaryEl) { + const button = this.makeButton(" \u21BA ", (e) => { + e.stopPropagation(); + this.updateSummary(summaryEl); + new import_obsidian2.Notice("Tag Summary updated"); + setTimeout(async () => { + this.processTags(); + }, 10); + }); + button.title = "Refresh Tag Summary"; + return button; + } + makeCopyToButton(content, section, paragraph, tags, filePath, paragraphEl, summaryEl) { + const buttonLabel = " \u274F " + this.truncateStringAtWord(section, 16); + const button = this.makeButton(buttonLabel, async (e) => { + e.stopPropagation(); + let newContent = content; + const prefix = this.settings.taggedParagraphCopyPrefix; + if (this.ctrlCmdKey(e)) { + tags.forEach((tag, i) => { + newContent = this.removeTagFromString(newContent, tag).trim(); + }); + } + const copySuccess = this.copyTextToSection(prefix + newContent, section, filePath); + if (copySuccess) { + if (this.ctrlCmdKey(e) && e.shiftKey) { + const file = this.app.vault.getAbstractFileByPath(filePath); + let fileContent = await this.app.vault.read(file); + fileContent = fileContent.trim(); + const newFileContent = this.replaceTextInString(content.trim(), fileContent, newContent).trim(); + if (fileContent != newFileContent) { + this.app.vault.modify(file, newFileContent); + const notice = new import_obsidian2.Notice("Paragraph moved to " + section + ".\n\u{1F517} Open source note.", 5e3); + this.removeElementWithAnimation(paragraphEl, () => { + setTimeout(async () => { + this.updateSummary(summaryEl); + paragraphEl.remove(); + }, 500); + setTimeout(async () => { + this.processTags(); + }, 800); + }); + this.registerDomEvent(notice.noticeEl, "click", (e2) => { + this.app.workspace.openLinkText(filePath, ""); + }); + } else { + new import_obsidian2.Notice("Tag Buddy: Paragraph copied to " + section + ".\nBut can't update source file."); + } + } else { + new import_obsidian2.Notice("Tag Buddy: Paragraph copied to " + section + "."); + } + } else { + } + }); + button.title = "Copy paragraph to " + section + ".\n" + this.ctrlCmdStr() + "+CLICK to remove tag(s) then copy.\n"; + button.title += "SHIFT+" + this.ctrlCmdStr() + "+CLICK to remove tags from source note paragraph."; + return button; + } + makeBakeButton(summaryMd, summaryEl, filePath) { + const button = this.makeButton("Bake", async (e) => { + e.stopPropagation(); + const mdSource = summaryEl.getAttribute("codeblock-code"); + if (mdSource) { + const file = this.app.vault.getAbstractFileByPath(filePath); + const fileContent = await this.app.vault.read(file); + const newFileContent = this.replaceTextInString(mdSource, fileContent, summaryMd); + this.app.vault.modify(file, newFileContent); + const notice = new import_obsidian2.Notice("Tag summary flattened to active note."); + } else { + new import_obsidian2.Notice("\u26A0\uFE0F Tag Buddy: Can find code block source. This is a BUG."); + } + }); + button.title = "Flatten summary (replaces code block)."; + return button; + } + makeCopyButton(content) { + const button = this.makeButton(" \u274F ", (e) => { + e.stopPropagation(); + navigator.clipboard.writeText(content); + const notice = new import_obsidian2.Notice("Tag Buddy: Copied to clipboard."); + }); + button.title = "Copy paragraph"; + return button; + } + ctrlCmdStr() { + const isMac = navigator.platform.toUpperCase().indexOf("MAC") >= 0; + if (isMac) + return "CMD"; + else + return "CTRL"; + } + /*tagsInString (string:string, tag:string=''):Array { + const regex = new RegExp(tag.replace(/\//g, '\\/') + "(?![\\w\\/\\#])", "g"); + const matches = string.match(regex); + console.log(matches) + return matches || []; //matches ? matches.length : 0; + }*/ + tagsInString(string, tag) { + let regex; + if (tag) { + regex = new RegExp(tag.replace(/\//g, "\\/") + "(?![\\w\\/\\#])", "g"); + } else { + regex = /#(\w+)(?![\w\/#])/g; + } + const matches = string.match(regex); + return matches || []; + } + countOccurrences(summaryTags, contentTags) { + let count = 0; + for (let tag of summaryTags) { + count += contentTags.filter((item) => item === tag).length; + } + return count; + } + makeRemoveTagButton(paragraphEl, tag, filePath) { + const button = this.makeButton(" \u2317\u02E3 ", (e) => { + e.stopPropagation(); + const tagEl = this.getTagElement(paragraphEl, tag); + this.editTag(tagEl); + }); + button.title = "Remove " + tag + " from paragraph (and from this summary)."; + return button; + } + removeElementWithAnimation(el, callback) { + const height = el.offsetHeight; + el.style.height = `${height}px`; + setTimeout(() => { + el.style.height = "0px"; + el.style.opacity = "0"; + el.style.margin = "0"; + el.style.padding = "0"; + }, 0); + el.addEventListener("transitionend", function onEnd() { + el.removeEventListener("transitionend", onEnd); + callback(); + }); + } + makeButton(lable, clickFn, classId = "tagsummary-button") { + const button = document.createElement("button"); + button.innerText = lable; + button.className = classId; + this.registerDomEvent(button, "click", clickFn.bind(this)); + return button; + } + getMarkdownHeadings(bodyLines) { + const headers = []; + let accumulatedIndex = 0; + bodyLines.forEach((line, index) => { + const match = line.match(/^(#+)[\s]?(.*)$/); + if (match) { + headers.push({ + fullText: match[0], + level: match[1].length, + text: match[2], + line: index, + startIndex: accumulatedIndex, + endIndex: accumulatedIndex + match[0].length - 1 + }); + } + accumulatedIndex += line.length + 1; + }); + return headers; + } + getLinesInString(input) { + const lines = []; + let tempString = input; + while (tempString.includes("\n")) { + const lineEndIndex = tempString.indexOf("\n"); + lines.push(tempString.slice(0, lineEndIndex)); + tempString = tempString.slice(lineEndIndex + 1); + } + lines.push(tempString); + return lines; + } + insertTextAfterLine(text, body, line, filePath) { + const splitContent = body.split("\n"); + const pre = splitContent.slice(0, line + 1).join("\n"); + const post = splitContent.slice(line + 1).join("\n"); + return `${pre} +${text} +${post}`; + } + async copyTextToSection(text, section, filePath) { + const file = await this.app.workspace.getActiveFile(); + const fileContent = await this.app.vault.read(file); + const fileContentLines = this.getLinesInString(fileContent); + const mdHeadings = this.getMarkdownHeadings(fileContentLines); + if (mdHeadings.length > 0) { + const headingObj = mdHeadings.find((heading) => heading.text.trim() === section); + if (headingObj) { + const textWithLink = text + ` [[${filePath}|\u{1F517}]]`; + let newContent = this.insertTextAfterLine(textWithLink, fileContent, headingObj.line); + await this.app.vault.modify(file, newContent); + return true; + } else { + new import_obsidian2.Notice(`Tag Buddy: ${section} not found.`); + return false; + } + } else { + new import_obsidian2.Notice("Tag Buddy: There are no header sections in this note."); + return false; + } + } + removeTagFromString(inputText, hashtagToRemove, all = true) { + const regex = new RegExp("\\s?" + hashtagToRemove.replace(/#/g, "\\#") + "(?!\\w|\\/)", all ? "gi" : "i"); + return inputText.replace(regex, "").trim(); + } + /*getSectionTitleWithHashes(sectionTitle) { + const activeView = this.app.workspace.getActiveViewOfType(MarkdownView); + if (!activeView) { + console.log('No active markdown view found.'); + return null; + } + + const contentEl = activeView.contentEl; + + // Get all heading elements + // This doesn't work with super long notes. + const headings = contentEl.querySelectorAll('h1, h2, h3, h4, h5, h6'); + //const headings = await contentEl.getElementsByClassName('h1, h2, h3, h4, h5, h6'); + + //console.log(headings) + for (const heading of headings) { + if (heading.textContent.trim() === sectionTitle.trim()) { + // Determine the number of hashes based on the heading level + const level = parseInt(heading.tagName.substr(1), 10); // e.g., "H2" -> 2 + const hashes = '#'.repeat(level); + //console.log(heading); + return {md:`${hashes} ${sectionTitle}`, el:heading}; + } + } + + console.log(`Section "${sectionTitle}" not found.`); + return null; + }*/ + truncateStringAtWord(str, maxChars) { + if (str.length <= maxChars) + return str; + let truncated = str.substr(0, maxChars); + const lastSpace = truncated.lastIndexOf(" "); + if (lastSpace > 0) + truncated = truncated.substr(0, lastSpace); + return truncated; + } + async readFiles(listFiles) { + let list = []; + for (let t = 0; t < listFiles.length; t += 1) { + const file = listFiles[t]; + let content = await this.app.vault.cachedRead(file); + list.push([file, content]); + } + return list; + } + isValidText(listTags, tags, include, exclude) { + let valid = true; + if (tags.length > 0) { + valid = valid && tags.some((value) => listTags.includes(value)); + } + if (include.length > 0) { + valid = valid && include.every((value) => listTags.includes(value)); + } + if (valid && exclude.length > 0) { + valid = !exclude.some((value) => listTags.includes(value)); + } + return valid; + } + async validateFilePath(filePath) { + const matchingFiles = await app.vault.getFiles().filter((file) => file.name === filePath); + if (matchingFiles.length === 1) { + const filePath2 = matchingFiles[0].path; + const file = await this.app.vault.getAbstractFileByPath(filePath2); + return file; + } else if (matchingFiles.length > 1) { + new import_obsidian2.Notice("Tag Buddy: Multiple files found with the same name. Can't safely edit tag."); + return null; + } else { + new import_obsidian2.Notice("Tag Buddy: No file found. Try again, or this tag might be in an unsupported embed type."); + return null; + } + } + contentChangedTooMuch(original, modified, tag, buffer = 5) { + const expectedChange = tag.length; + const threshold = expectedChange + buffer; + const actualChange = Math.abs(original.length - modified.length); + return actualChange > threshold; + } + async loadSettings() { + this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData()); + } + async saveSettings() { + await this.saveData(this.settings); + } + isTagValid(tag) { + const tagPattern = /^#[\w]+$/; + return tagPattern.test(tag); + } + saveRecentTag(tag) { + if (this.isTagValid(tag)) { + const recentTagsString = this.settings.recentlyAddedTags; + let recentTags; + if (recentTagsString == "") { + recentTags = []; + } else if (recentTagsString.indexOf(", ")) { + recentTags = this.settings.recentlyAddedTags.split(", "); + } else { + recentTags = [this.settings.recentlyAddedTags]; + } + if (recentTags.includes(tag)) { + recentTags.splice(recentTags.indexOf(tag), 1); + } + recentTags.unshift(tag.trim()); + recentTags = recentTags.slice(0, 3); + this.settings.recentlyAddedTags = recentTags.join(", "); + this.saveSettings(); + } + } + getRecentTags() { + const recentTags = this.settings.recentlyAddedTags == "" ? [] : this.settings.recentlyAddedTags.split(", "); + return recentTags; + } + // fuck.this.function + /*cleanString(input) { + let cleanedStr; + + // Check if input is a DOM element + if (input instanceof Element) { + //console.log('input is: Element'); + cleanedStr = input.outerHTML.trim(); + } else { + //console.log('input is: String'); + cleanedStr = input.trim(); + } + + // Whitespace normalization + //cleanedStr = cleanedStr.replace(/\s+/g, ' '); + + // Remove
elements + //cleanedStr = cleanedStr.replace(/
/g, ' '); + + // Remove blockquote tags but keep their content + //cleanedStr = cleanedStr.replace(/<\/?blockquote>/g, ''); + + // Remove blockquote tags but keep their content + //cleanedStr = cleanedStr.replace(/<\/?div>/g, ''); + + // Remove spaces between tags + //cleanedStr = cleanedStr.replace(/>\s+<'); + + // Whitespace normalization + cleanedStr = cleanedStr.replace(/\s+/g, ' '); + + // HTML entity decoding + const textArea = document.createElement('textarea'); + textArea.innerHTML = cleanedStr; + cleanedStr = textArea.value.trim(); + + // Optional: convert to lowercase + // cleanedStr = cleanedStr.toLowerCase(); + + return cleanedStr; + }*/ + /*async refreshView (){ + //console.log('Refresh view.'); + new Notice ('Refresh view.'); + // if using rerender, + //const scrollState = this.app.workspace.getActiveViewOfType(MarkdownView)?.currentMode?.getScroll(); + //await view.previewMode.rerender(true); + + await app.workspace.activeLeaf.rebuildView(); + // only needed if we use rerender above. do this on a timeout + //this.app.workspace.getActiveViewOfType(MarkdownView).previewMode.applyScroll(scrollState); + }*/ + injectStyles() { + const styles = ` + .tagsummary-notags { + color: var(--link-color) !important; + font-weight: 500 !important; + border: 1px solid var(--link-color) !important; + border-radius: 5px !important; + padding: 10px 10px; + } + + .tagsummary-button { + + color: var(--text-primary) !important; + /*border: .5px solid var(--text-quote) !important;*/ + border-radius: 6px !important; + padding: 2.5px 5px !important; + font-size: 65% !important; + transition: background-color 0.3s !important; + margin: 0px 3px 0px 0px !important; + min-width: 40px !important; + + color: var(--link-color) !important; + border: 1px solid var(--link-color) !important; + background-color: var(--background-primary) !important; + + } + + .tagsummary-button:hover { + background-color: var(--link-color) !important; + color: var(--background-secondary) !important; + } + + .tagsummary-item-title { + margin: 5px 0px + } + + .tagsummary-buttons { + /*float: right;*/ + text-align: right !important; + } + + blockquote.tag-summary-paragraph { + transition: height 0.3s, opacity 0.3s; + /*transition: height 0.3s ease, margin 0.3s ease, padding 0.3s ease, opacity 0.3s ease;*/ + overflow: hidden; + } + + .removing { + height: 0 !important; + opacity: 0; + margin: 0; + padding: 0; + } + + @media only screen and (max-device-width: 480px), + only screen and (max-width: 480px) and (orientation: landscape), + only screen and (max-device-width: 1024px), + only screen and (min-width: 481px) and (max-width: 1024px) and (orientation: landscape) { + .tagsummary-button { + display: inline-block !important; + font-size: 12px !important; + padding: 5px 5px; + box-shadow: none; /* remove shadows if they look off */ + border-radius: 4px; + color: var(--link-color) !important; + border: 1px solid var(--link-color); + width: auto !important; /* auto adjusts width based on content */ + /*max-width: 60px !important; */ + max-height: 30px !important; + min-width: 40px !important; + white-space: nowrap; + /*text-align: left !important;*/ + overflow: hidden; + background-color: var(--background-primary) !important; + } + } + + .addtag-menu { + position: absolute !important; + background-color: var(--background-primary) !important; + /*color: white !important;*/ + border: 2px solid var(--divider-color) !important; + z-index: 10000 !important; + overflow-y: auto !important; + /*max-height: 150px !important;*/ + width: 150px !important; + box-shadow: 5px 5px 20px rgba(0, 0, 0, 0.5) !important; + border-radius: 8px !important; + font-family: Arial, sans-serif; + font-size: 12px !important; + overflow: hidden !important; // Hide overflow + padding-right: 10px !important; // Adjust padding to make space for scrollbar + box-sizing: border-box !important; + + border-radius: 10px !important; + + } + + .tag-list { + overflow-y: auto !important; + overflow-x: hidden !important; + /*padding-right: 8px !important; // Adjust padding to give space for scrollbar + /*margin-right: -8px !important; // Adjust margin to move scrollbar into the padding*/ + box-sizing: border-box !important; + } + + .tag-item { + padding: 5px 10px 5px 10px !important; + cursor: pointer !important; + /* border-bottom: 1px solid var(--divider-color) !important; // Separator line*/ + font-size: 14px !important; + /*width: 130px !important;*/ + width: 100% !important; + /*height: 20px !important;*/ + text-overflow: ellipsis !important; + white-space: nowrap !important; + box-sizing: border-box !important; + + + transition: background-color 0.2s ease !important; + border-radius: 5px !important; + } + + .tag-item:hover { + background-color: var(--background-modifier-hover) !important; // Added ,1 for opacity + /*color: white !important;*/ + } + .tag-item.active { + background-color: var(--background-modifier-hover) !important; + /*background-color: var(--interactive-accent) !important;*/ + /*color: white !important;*/ + } + + #addtag-menu .disable-hover .tag-item:hover { + background-color: inherit !important; + color: inherit !important; + } + + .tag-search { + width: 100% !important; + padding: 2.5px 5px !important; + border: none !important; + font-family: Arial, sans-serif; + font-size: 14px !important; + } + + .tag-search:focus { + outline: none !important; + border: none !important; + border-bottom: 0px !important; + box-shadow: none !important; + outline-style: none !important; + outline-width: 0px !important; + + + } + + `; + const styleSheet = createEl("style"); + styleSheet.type = "text/css"; + styleSheet.innerText = styles; + styleSheet.id = "tag-buddy-styles"; + document.head.appendChild(styleSheet); + } + async getEmbedFile(el) { + let filePath = el.getAttribute("src"); + const linkArray = filePath.split("#"); + filePath = linkArray[0].trim() + ".md"; + const file = await this.validateFilePath(filePath); + return file; + } + async getSummaryFile(el) { + const filePath = el.getAttribute("file-source"); + const file = await this.app.vault.getAbstractFileByPath(filePath); + return file; + } + showTagSelector(x, y) { + const maxTagContainerHeight = 170; + const tagItemHeight = 30; + const existingMenu = document.getElementById("addtag-menu"); + if (existingMenu) + existingMenu.remove(); + const menuEl = createEl("div"); + menuEl.setAttribute("id", "addtag-menu"); + menuEl.classList.add("addtag-menu"); + menuEl.style.left = `${x}px`; + menuEl.style.top = `${y}px`; + const searchEl = createEl("input"); + searchEl.setAttribute("type", "text"); + searchEl.setAttribute("id", "tag-search"); + searchEl.classList.add("tag-search"); + searchEl.setAttribute("placeholder", "Search tags..."); + menuEl.appendChild(searchEl); + const tagContainer = createEl("div"); + tagContainer.classList.add("tag-list"); + tagContainer.style.setProperty("max-height", `${maxTagContainerHeight}px`, "important"); + menuEl.appendChild(tagContainer); + const renderTags = (searchQuery) => { + tagContainer.innerHTML = ""; + const filteredTags = this.getTagsFromApp().filter((tag) => tag.toLowerCase().includes(searchQuery.toLowerCase())); + const dynamicHeight = Math.min(filteredTags.length * tagItemHeight, maxTagContainerHeight); + filteredTags.forEach((tag, index) => { + const itemEl = createEl("div"); + itemEl.innerText = `${tag}`; + itemEl.classList.add("tag-item"); + itemEl.title = `#${tag}`; + if (index === 0) { + itemEl.classList.add("active"); + } + itemEl.style.setProperty("max-height", `${dynamicHeight}px`, "important"); + this.registerDomEvent(itemEl, "click", (e) => { + this.addTag("#" + tag, x, y); + menuEl.remove(); + }, true); + tagContainer.appendChild(itemEl); + }); + if (filteredTags.length * tagItemHeight > maxTagContainerHeight) { + tagContainer.style.overflowY = "auto !important"; + } else { + tagContainer.style.overflowY = "hidden !important"; + } + }; + this.registerDomEvent(searchEl, "keyup", (e) => { + const searchQuery = e.target.value.trim(); + const pattern = /^[^\s\p{P}]+$/u; + if (e.key === "Enter") { + const activeTag = tagContainer.querySelector(".active"); + if (activeTag) { + this.addTag("#" + activeTag.innerText, x, y); + } else if (pattern.test(searchQuery)) { + this.addTag("#" + searchQuery, x, y); + } + menuEl.remove(); + } + }); + renderTags(""); + searchEl.addEventListener("input", (e) => { + renderTags(e.target.value); + }); + document.body.appendChild(menuEl); + searchEl.focus(); + const closeMenu = (e) => { + if (e instanceof MouseEvent && (e.button === 0 || e.button === 2)) { + if (!menuEl.contains(e.target)) { + menuEl.remove(); + document.body.removeEventListener("click", closeMenu); + document.body.removeEventListener("contextmenu", closeMenu); + document.body.removeEventListener("keyup", closeMenu); + } + } else if (e instanceof KeyboardEvent && e.key === "Escape") { + menuEl.remove(); + document.body.removeEventListener("click", closeMenu); + document.body.removeEventListener("contextmenu", closeMenu); + document.body.removeEventListener("keyup", closeMenu); + } + }; + setTimeout(() => { + this.registerDomEvent(document.body, "click", closeMenu); + this.registerDomEvent(document.body, "contextmenu", closeMenu); + this.registerDomEvent(document.body, "keyup", closeMenu); + }, 0); + this.registerDomEvent(tagContainer, "mousemove", () => { + tagContainer.classList.remove("disable-hover"); + const activeTag = tagContainer.querySelector(".tag-item.active"); + if (activeTag) { + activeTag.classList.remove("active"); + } + }); + this.registerDomEvent(searchEl, "blur", () => { + tagContainer.classList.remove("disable-hover"); + }); + this.registerDomEvent(searchEl, "keydown", (e) => { + const activeTag = tagContainer.querySelector(".active"); + let nextActiveTag; + if (["ArrowUp", "ArrowDown"].includes(e.key) || e.key.length === 1) { + tagContainer.classList.add("disable-hover"); + } + if (e.key === "ArrowDown") { + if (activeTag && activeTag.nextElementSibling) { + nextActiveTag = activeTag.nextElementSibling; + } else { + nextActiveTag = tagContainer.firstChild; + } + } else if (e.key === "ArrowUp") { + if (activeTag && activeTag.previousElementSibling) { + nextActiveTag = activeTag.previousElementSibling; + } else { + nextActiveTag = tagContainer.lastChild; + } + } else if (e.key === "Enter") { + } + if (nextActiveTag) { + if (activeTag) { + activeTag.classList.remove("active"); + } + nextActiveTag.classList.add("active"); + nextActiveTag.scrollIntoView({ block: "nearest" }); + searchEl.value = nextActiveTag.innerText; + } + }); + } + async addTag(tag, x, y) { + if (this.settings.debugMode) { + console.log("Tag Buddy add"); + console.log(x, y, tag); + } + let fileContent; + let file; + const clickedTextObj = this.getClickedTextObjFromDoc(x, y); + const clickedText = clickedTextObj == null ? void 0 : clickedTextObj.text; + const clickedTextIndex = clickedTextObj == null ? void 0 : clickedTextObj.index; + const clickedTextEl = clickedTextObj == null ? void 0 : clickedTextObj.el; + let contentSourceType = null; + let summaryEl; + let embedEl; + if (clickedTextObj) { + summaryEl = clickedTextEl.closest(".tag-summary-paragraph"); + embedEl = clickedTextEl.closest(".markdown-embed"); + if (summaryEl) { + file = await this.getSummaryFile(summaryEl); + fileContent = await this.app.vault.read(file); + contentSourceType = "plugin-summary"; + } else if (embedEl) { + file = await this.getEmbedFile(embedEl); + fileContent = await this.app.vault.read(file); + contentSourceType = "native-embed"; + } else { + file = await this.app.workspace.getActiveFile(); + fileContent = await this.app.vault.read(file); + contentSourceType = "active"; + } + } else { + new import_obsidian2.Notice("\u26A0\uFE0F Can't find text position or area too busy.\nTry a another text area."); + return; + } + if (clickedText) { + } else { + new import_obsidian2.Notice("\u26A0\uFE0F Can't add tag.\nTry a different text area."); + return; + } + const escapedClickedText = this.escapeRegExp(clickedText); + const regex = new RegExp(escapedClickedText, "g"); + const matches = fileContent.match(regex); + if (matches && matches.length > 1) { + new import_obsidian2.Notice("\u26A0\uFE0F Can't add tag: Clicked text repeated in note. Try a another text block."); + return; + } else if (matches && matches.length === 0 || !matches) { + new import_obsidian2.Notice("\u26A0\uFE0F Can't find text position or area too busy.\nTry a another text area."); + return; + } + if (!this.settings.lockRecentTags) + this.saveRecentTag(tag); + const startIndex = regex.exec(fileContent).index; + const endIndex = startIndex + clickedText.length - 1; + const clickedWordObj = this.getWordObjFromString(clickedText, clickedTextIndex); + const clickedWord = clickedWordObj.text; + const clickedWordIndex = clickedWordObj.index; + const newContent = this.insertTextInString(tag, fileContent, startIndex + clickedWordIndex); + await this.app.vault.modify(file, newContent); + if (contentSourceType == "plugin-summary") { + const summaryContainer = summaryEl.closest(".tag-summary-block"); + this.updateSummary(summaryContainer); + } + setTimeout(async () => { + this.processTags(); + }, 200); + } + replaceTextInString(replaceText, sourceText, newText, all = false) { + const regex = new RegExp(this.escapeRegExp(replaceText), all ? "gi" : "i"); + return sourceText.replace(regex, newText).trim(); + } + // I removed .trim() from the before and after to fix the add bug. + insertTextInString(newText, sourceText, charPos) { + return sourceText.substring(0, charPos) + " " + newText + " " + sourceText.substring(charPos); + } + removeTextFromString(removeText, sourceText, all = false) { + const regex = new RegExp(this.escapeRegExp(removeText), all ? "gi" : "i"); + return sourceText.replace(regex, "").trim(); + } + getWordObjFromString(sourceText, offset) { + let wordRegex = /[^\s]+(?=[.,:!?]?(\s|$))/g; + let match; + let index; + let word = null; + while ((match = wordRegex.exec(sourceText)) !== null) { + if (match.index <= offset && offset <= match.index + match[0].length) { + word = match[0]; + index = match.index; + break; + } + } + return { text: word, index }; + } + getClickedTextObjFromDoc(x, y, minNodeLength = 10) { + let range, nodeText, offset; + if (document.caretRangeFromPoint) { + range = document.caretRangeFromPoint(x, y); + if (range.startContainer.nodeType === Node.TEXT_NODE) { + nodeText = range.startContainer.nodeValue.trim(); + } else { + return null; + } + offset = range.startOffset; + } + if (nodeText.length < minNodeLength) { + return null; + } + return { text: nodeText, index: offset, el: range.startContainer.parentNode }; + } + /*async getClickedWord(e) { + //Get the click position + let x = e.clientX, y = e.clientY; + + // Get the word under the click position + let range, textNode, offset; + + // This method is better supported and gives us a range object + if (document.caretRangeFromPoint) { + range = document.caretRangeFromPoint(x, y); + textNode = range.startContainer; + offset = range.startOffset; + } + //console.log(textNode) + + // LATER, double check different notes types and around the interface + + // Check if we have a valid text node + if (textNode && textNode.nodeType === Node.TEXT_NODE) { + // Get the whole text of the clicked node + let fullText = textNode.textContent; + + // LATER: if the word end in valid punctuation, add a space between word and punctuation it when adding the hash. + // LATER, have predefined tags we can insert with different key modifiers on click + // like, #todo or #inbox #later + + let wordRegex = /[^\s]+(?=[.,:!?]?(\s|$))/g; + let match; + let clickedWord = null; + while ((match = wordRegex.exec(fullText)) !== null) { + if (match.index <= offset && offset <= match.index + match[0].length) { + // This is our word + if (!/^[^\p{L}\p{N}]/u.test(match[0]) && // Not starting with any non-alphanumeric + !/[^\p{L}\p{N}\s.,:!?]/u.test(match[0]) && // Not containing other than allowed chars + !/[.,:!?](?=[^\s$])/u.test(match[0])) { // If ends with punctuation, following character must be whitespace or end of string + clickedWord = match[0]; + break; + } + } + } + + + let activeView = await this.app.workspace.getActiveViewOfType(MarkdownView); + + + let editor = activeView.sourceMode.cmEditor; // Get the CodeMirror instance + let fullNote = editor.getValue(); + + const globalStartPosition = fullNote.indexOf(textNode.textContent); + + if (globalStartPosition !== -1) { + // Assuming the click was right at the end of the word + let wordEndPosition = globalStartPosition + offset; + + // Traverse backward until a space or start + while (wordEndPosition > 0 && fullNote[wordEndPosition] !== ' ' && fullNote[wordEndPosition] !== '\n') { + wordEndPosition--; + } + + wordEndPosition++; + + // Insert hash at wordEndPosition + const updatedNote = [fullNote.slice(0, wordEndPosition), '#', fullNote.slice(wordEndPosition)].join(''); + console.log(updatedNote); + } + + + } + + // LATER, to make this work in embeds and summaries + // and avoid adding when in the summary empty block. or other code blocks. maybe this check is earlier. + }*/ + escapeRegExp(string) { + return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); + } + getTagsFromApp() { + const tagsObject = this.app.metadataCache.getTags(); + const tagsArray = Object.entries(tagsObject); + tagsArray.sort((a, b) => b[1] - a[1]); + const recentTags = this.getRecentTags(); + if (recentTags.length > 0) { + const recentTagsAsTuples = recentTags.map((tag) => [tag, 0]); + const recentAndAllTags = recentTagsAsTuples.concat(tagsArray); + return recentAndAllTags.map(([tag, _]) => tag.replace(/^#/, "")); + } else { + return tagsArray.map(([tag, _]) => tag.replace(/^#/, "")); + } + } + getTagElement(paragraphEl, tagText) { + const els = paragraphEl.querySelectorAll(".tag"); + let tagElText = ""; + let tagElHasSub; + for (let el of els) { + tagElText = el.innerText.trim(); + if (tagElText === tagText) { + return el; + } + } + console.warn(`Element with text "${tagText}" not found`); + return null; + } + ctrlCmdKey(event) { + const isMac = navigator.platform.toUpperCase().indexOf("MAC") >= 0; + if (isMac) + return event.metaKey; + else + return event.ctrlKey; + } + debounce(func, wait) { + let timeout; + return function(...args) { + const context = this; + clearTimeout(timeout); + timeout = setTimeout(() => { + func.apply(context, args); + }, wait); + }; + } +}; +var TempComponent = class extends import_obsidian2.Component { + onload() { + } + onunload() { + } +}; +var DoubleTapHandler = class { + constructor(plugin, element, callback) { + this.plugin = plugin; + this.element = element; + this.callback = callback; + this.lastTap = 0; + this.plugin.registerDomEvent(this.element, "touchend", this.handleTouchEnd.bind(this), true); + } + handleTouchEnd(event) { + const currentTime = new Date().getTime(); + const tapLength = currentTime - this.lastTap; + clearTimeout(this.timeout); + if (tapLength < 500 && tapLength > 0) { + this.callback(event); + } else { + this.timeout = setTimeout(() => { + clearTimeout(this.timeout); + }, 500); + } + this.lastTap = currentTime; + } +}; +var PressAndHoldHandler = class { + constructor(plugin, element, callback, duration = 600) { + this.plugin = plugin; + this.element = element; + this.callback = callback; + this.duration = duration; + this.timeout = null; + this.plugin.registerDomEvent(this.element, "touchstart", this.handleTouchStart.bind(this), true); + this.plugin.registerDomEvent(this.element, "touchend", this.handleTouchEnd.bind(this), true); + } + handleTouchStart(event) { + this.timeout = setTimeout(() => { + this.callback(event); + this.timeout = null; + }, this.duration); + } + handleTouchEnd(event) { + if (this.timeout) { + clearTimeout(this.timeout); + this.timeout = null; + } + } +}; +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["main.ts", "settings.ts"],
  "sourcesContent": ["import { TBSettingsTab } from \"./settings\";\nimport { App, debounce, Editor, MarkdownRenderer, Component, TFile, getAllTags, MarkdownView, Modal, Notice, Plugin, PluginSettingTab, Setting } from 'obsidian';\n\nimport { getTagsFromApp } from './utils';\n//import { showTagSelector } from './ui'; // need to give these files reference to the plugin\ninterface TBSettings {\n\tremoveOnClick: boolean; // ctrl\n\tremoveChildTagsFirst; // \n\toptToConvert: boolean; //alt\n\tmobileTagSearch: boolean; \n\tmobileNotices: boolean; \n\ttagSummaryBlockButtons: boolean; \n\ttaggedParagraphCopyPrefix: string;\n\trecentlyAddedTags: string;\n\tlockRecentTags: boolean;\n\tshowSummaryButtons:boolean;\n\tdebugMode: boolean;\n}\n\nconst DEFAULT_SETTINGS: Partial<TBSettings> = {\n\tremoveOnClick: true, // when true, cmd is needed when clicking to remove the tag\n\tremoveChildTagsFirst: true, // use shift when false\n\toptToConvert: true, // when false, clicking tag will do nothing\n\tmobileTagSearch: false, // toggle on use double tap for search. press+hold will then remove.\n\tmobileNotices: true,\n\ttagSummaryBlockButtons: false,\n\ttaggedParagraphCopyPrefix: '',\n\trecentlyAddedTags: '',\n\tlockRecentTags: false,\n\tshowSummaryButtons:false,\n\tdebugMode: false,\n}; \n\nexport default class TagBuddy extends Plugin {  \n\tsettings: TBSettings;\n\n\tonunload() { // I think all the cleanup is done automatically the way I register everthing. \n\t} \n\n\tasync onload() {\n\t\tawait this.loadSettings();\n\t\tthis.addSettingTab(new TBSettingsTab(this.app, this));\t\n\t\t\n\t\tconsole.log('Tag Buddy Plugin loaded on ' + (this.app.isMobile?'mobile at ':'desktop at ') + new Date().toUTCString().substring(17));\n\t\t\n\t\tthis.injectStyles();\n\n\t\tconst debouncedProcessTags = this.debounce(this.processTags.bind(this), 500);\n\n\t\tthis.app.workspace.onLayoutReady(async () => {\n\n\t\t\t// Need to figure out how to get the current mouse position\n\t\t\t/*this.addCommand({\n\t\t\t    id: 'open-tag-selector',\n\t\t\t    name: 'Tag Buddy: Add tag at mouse position',\n\t\t\t    callback: (event) => {\n\t\t\t         setTimeout(() => {\n\t\t\t            const x = event.clientX;\n\t\t\t            const y = event.clientY;\n\t\t\t            this.showTagSelector(x, y);\n\t\t\t        }, 50);\n\t\t\t    }\n\t\t\t});*/ \n\n\t\t\t// this.reload(); // no need for this atm.\n\t\t\tsetTimeout(async () => { this.processTags(); }, 500)\n\t\t\t\n\n\t\t    this.registerEvent( this.app.workspace.on('active-leaf-change', async () => { \n\t\t    \t//console.log('active leaf change'); \n\t    \t\t\n\t    \t\t/*this.registerDomEvent(document, 'contextmenu', async (event: MouseEvent) => {\n\t    \t\t\tconst view = await this.app.workspace.getActiveViewOfType(MarkdownView);\n\t\t\t        if (view && this.ctrlCmdKey (event) && (view.getMode() == 'preview')) {\n\t\t\t            event.preventDefault();\n\t\t\t            console.log('right click')\n\t\t\t            const file = await this.app.workspace.getActiveFile();\n\n\t\t\t            this.showTagSelector(event.pageX, event.pageY, file);\n\t\t\t        }\n\t\t\t    });*/\n\t\t    }));\n\n\n\t\t    this.registerDomEvent(document, 'contextmenu', async (event: MouseEvent) => {\n    \t\t\tconst view = await this.app.workspace.getActiveViewOfType(MarkdownView);\n\t\t        if (view && this.ctrlCmdKey (event) && (view.getMode() == 'preview')) {\n\t\t            event.preventDefault();\n\t\t            //console.log('right click')\n\t\t            const file = await this.app.workspace.getActiveFile();\n\t\t            //console.log(view)\n\t\t            this.showTagSelector(event.pageX, event.pageY, file);\n\t\t        }\n\t\t    });\n\n\t\t\t// Don't need this event because we'll always need to switch between views to edit note and affect the tag indices.\n\t\t\t// this.registerEvent(this.app.workspace.on('editor-change', debounce(async () => { console.log('editor change'); this.processTags(); }, 3000, true)));\n\t\t\t// This event is best because we always need to switch modes to edit note or interact with tag (reading mode).\n\t\t\t// this.registerEvent(this.app.workspace.on(\"editor-menu\", this.onEditorMenu, this));\n\t\t\t// this.registerEvent( this.app.workspace.on('editor-menu', debounce(async () => { console.log('active leaf change'); this.processTags(); }, 300, true)) );\n\n\t\t\tthis.registerEvent( this.app.on('layout-change', (event: EditorEvent) => {  \n\t\t\t\t//setTimeout(async () => { \n\t\t\t\t //console.log('layout change'); \n\t\t\t\t\t//this.processTags(); \n\t\t\t\t\tdebouncedProcessTags();\n\t\t\t\t//}, 300); \n\t\t\t}));\n\t\t\t\n\t\t\t// There is a little redundancy here because we also get layout events when switching files\n\t\t\tthis.registerEvent(this.app.on('file-open', async (event: EditorEvent) => { \n\t\t\t\t//setTimeout(async () => { \n\t\t\t\t //console.log('file open'); \n\t\t\t\t\t//this.processTags(); \n\t\t\t\t\tdebouncedProcessTags();\n\t\t\t\t//}, 1000); \n\t\t\t}));\n\n\t\t\t\n\n\t\t\tif (!this.app.isMobile) {\n\n\t\t\t\t// This event handles all the interactions on desktop\n\t\t\t\tthis.registerDomEvent(document, 'click', this.onClickEvent.bind(this), true);\n\n\t\t\t} else { // Mobile interaction\n\n\t\t\t\t// This event catches all taps on mobile because we have custom double-tap and press-hold events.\n\t\t\t\t// But we only stop all other system events if this click was on a tag. Then we takeover. \n\t\t\t\tthis.registerDomEvent(document, 'click', (e) => { \n\t\t\t\t\tconst isTag = e.target.classList.contains('tag');\n\t\t\t\t\tif (isTag && !this.settings.mobileTagSearch) {\n\t\t\t\t\t\t//new Notice ('stop prop')\n\t\t\t\t\t\te.stopPropagation();\n\t\t\t\t\t}\n\t\t\t\t}, true);\n\n\t\t\t\tnew PressAndHoldHandler(this, document, this.onClickEvent.bind(this));\n\t\t\t\tnew DoubleTapHandler(this, document, this.onClickEvent.bind(this));\n\t\t\t}\t\n\t\t\t\n\t\t});\n\n\t\t// Tag summary code block\n\t\tthis.registerMarkdownCodeBlockProcessor(\"tag-summary\", this.summaryCodeBlockProcessor.bind(this));\n\t}\n\n\tasync onClickEvent (event) {\n\t\t\n\t\t// Support for different views? \n\t\t// If tag has no context properties, then try to figure out where it is?\n\t\t// Or maybe there's a way to have obsidian add the properties globally.\n\t\t//new Notice ('Tag Buddy event type: ' + event.type);\n\n\t\t//console.log((navigator.platform.toUpperCase().indexOf('MAC') >= 0)?'This is a Mac':'This is not a Mac')\n\n\t\tconst target = event.target as HTMLElement;\n\t\tconst view = await this.app.workspace.getActiveViewOfType(MarkdownView);\n\n\t\t// This condition it in case we click on a tag in another plugin like repeat or checklist\n\t\t// can't edit tags in these cases. For now.\n\t\tif (!view && target.matches('.tag')) { \n\t\t\tnew Notice('Tag Buddy: Can\\'t edit tag. Unsupported view type. Try again within that note.');\n\t\t\treturn;\n\t\t}\n\n\t\tif (view) { \n\t\t\tif (view.getMode() != 'preview') return;\n\t\t} else {\n\t\t\t//if (document.contains('repeat-embedded_note'))\n\t\t}\n\t\t\n\t\tif (!this.app.isMobile) {\n\t\t\t//new Notice ('Tag Buddy event type: ' + event.type);\n\n\t\tif ((this.settings.removeOnClick && this.ctrlCmdKey(event)) || (!this.settings.removeOnClick && !this.ctrlCmdKey(event))) { \n\t\t\treturn; \n\t\t} else if (event.altKey && !this.settings.optToConvert) {  \n\t\t\treturn; \n\t\t}\n\n\t\t} else {\n\t\t\t\n\t\t\tif (this.settings.mobileTagSearch && event.type == 'touchend') {\n\t\t\t\t// if we get this far, this is a double tap\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\n\n\t\t\n\t\t//if (view && target && target.matches('.tag')) {\t\n\t\tif (target && target.matches('.tag')) {\t\n\t\t\t// const scrollState = this.app.workspace.getActiveViewOfType(MarkdownView)?.currentMode?.getScroll();\n\n\t\t\tif (this.settings.removeOnClick || (!this.settings.removeOnClick && this.ctrlCmdKey(event))) {\n\t\t\t\tevent.stopPropagation();\n\t\t\t\tevent.preventDefault();\n\t\t\t}\n\n\t\t\tconst clickedTag = target.closest('.tag'); //event.target as HTMLElement;\n\t\t\tconst tag = clickedTag.innerText;\n\n\t\t\tlet tagIndex = clickedTag.getAttribute('md-index');\n\t\t\tlet tagFile = clickedTag.getAttribute('file-source');\n\n\t\t\tif (tagFile) {\n\t\t\t\t// Try\n\t\t\t\t//this.editTag (event, tagIndex, tagFile);\n\t\t\t\tthis.editTag (target, event);\n\t\t\t} else {\n\t\t\t\t// Try again\n\t\t\t\tsetTimeout(async () => {\n\t\t\t\t\ttagIndex = clickedTag.getAttribute('md-index');\n\t\t\t\t\ttagFile = clickedTag.getAttribute('file-source');\n\t\t\t\t\t//this.editTag (event, tagIndex, tagFile);\n\t\t\t\t\tthis.editTag (target, event);\n\t\t\t\t}, 300);\n\t\t\t}\n\t\t\t//console.log(clickedTag.getAttribute('type'))\n\n\t\t\t\n\t\t//} else if (view == null && target && target.matches('.tag')) {\n\t\t} else if (!view && target.matches('.tag')) {\n\t\t\tnew Notice('Tag Buddy: Can\\'t edit tag. Might be in an unsupported view type.');\n\t\t}\n\t}\n\n\tasync editTag (tagEl, event, pragraphEl) {\n\t\t//console.log(tagEl)\n\n\t\tconst index = tagEl.getAttribute('md-index');\n\t\tconst filePath = tagEl.getAttribute('file-source');\n\n\t\t//if (this.settings.debugMode) console.log('Tag Buddy edit tag: ' + event.target.innerText + '\\nIn file: ' + filePath);\n\t\tif (this.settings.debugMode) console.log('Tag Buddy edit tag: ' + tagEl.innerText + '\\nIn file: ' + filePath);\n\n\t\tif (filePath) {\n\n\t\t\tconst file: TFile = await this.validateFilePath(filePath); //app.vault.getAbstractFileByPath(filePath);\n\t\t\tlet fileContent: String;\n\t\t\tlet fileContentBackup: String;\n\t\t\t//const tag: String = event.target.innerText.trim();\n\t\t\tconst tag: String = tagEl.innerText.trim();\n\n\t\t\ttry {\n\t\t\t\t\n\t\t\t\tfileContent = await this.app.vault.read(file);\n\t\t\t\tfileContentBackup = fileContent;\n\n\t\t\t} catch (error) {\n\n\t\t\t\tnew Notice('Tag Buddy file read error:\\n' + error.message);\n\t\t\t\treturn;\n\n\t\t\t}\n\n\t\t\t//console.log(this.getClickedTextObjFromDoc(event.pageX, event.pageY, 0))\n\n\t\t\t// check if the file has only one tag left (and that's all thats left in the file)\n\t\t\tlet safeToEmptyFile = false;\n\t\t\tconst tagRegex = /^\\s*#(\\w+)\\s*$/;\n\t\t\tif (tagRegex.test(fileContent.trim())) {\n\t\t    \tsafeToEmptyFile = true;\n\t\t\t}\n\t\t\t\n\t\t\tlet beforeTag = fileContent.substring(0, index);\n\t\t\t//let afterTag = fileContent.substring((Number(index)+Number(tag.length)+1));\n\t\t\tlet afterTag = fileContent.substring((Number(index)+Number(tag.length)));\n\n\t\t\tlet afterTagChr;\n\t\t\tlet beforeTagChr\n//console.log(JSON.stringify(beforeTag))\n\t\t\t\n//console.log ('before tag ends with space? ' + before.startsWith(' '))\n//console.log ('before tag ends with linebreak? ' + before.startsWith('\\n'))\n\t\t\tif (afterTag.startsWith(' ')) {\n\t\t\t\tafterTagChr = ' ';\n\t\t\t} else if (afterTag.startsWith('\\n')) {\n\t\t\t\tafterTagChr = '\\n';\n\t\t\t}\n\n\t\t\t// can't remember why I have this...\n\t\t\t// need to refactor all this line break space stuff\n\t\t\tif (fileContent[index] === '\\n') {\n    \t\t\tbeforeTag += '\\n'; // appending the newline character to beforeTag\n\t\t\t}\n\t\t\t\n\t\t\t//console.log('File content: ', JSON.stringify(fileContent));\n\t\t\t//console.log ('------------------------------------------------');\n\t\t\t//console.log('Before Tag: ', JSON.stringify(beforeTag));\n\t\t\t//console.log ('------------------------------------------------');\n\t\t\t//console.log('The Tag: ', JSON.stringify(tag));\n\t\t\t//console.log ('------------------------------------------------');\n\t\t\t//console.log('After Tag: ', JSON.stringify(afterTag));\n\t\n\t\t\tlet newContent = '';\n\n\t\t\t//if (this.settings.debugMode) {\n\n\t\t\t\t// newContent = beforeTag + ' \u26A0\uFE0F---\uD83E\uDEF8' + tag + '\uD83E\uDEF7---\u26A0\uFE0F ' + afterTag;\n\t\t\t\t//newContent = beforeTag + ' \u26A0\uFE0F---\u27A1\uFE0F' + tag + afterTag;\n\n\t\t\t//} else\n\n\t\t\t////////////////////////////////////////////////////////////////\n\t\t\t// SUPER MESSY. NEED TO REFACTOR\n\t\t\t////////////////////////////////////////////////////////////////\n\n\n\t\t\tif (!event) { // then we're calling this method from a button. need to rethink how this is organized.\n\t\t\t\t\n\t\t\t\t//afterTagChr = afterTag.endsWith(' ')?' ':''\n\t\t\t\tnewContent = beforeTag + afterTagChr + afterTag //+ afterTagChr;\n\n\t\t\t} else if (event.altKey || ((event.type == 'touchstart') && !this.settings.mobileTagSearch)) { \n\n\t\t\t\t// Remove the hash only\n\n\t\t\t\tconst noHash = tag.substring(1);\n\t\t\t\t//newContent = beforeTag + (!beforeTag.endsWith(' ')?' ':'') + noHash + afterTag;\n\t\t\t\tnewContent = beforeTag + noHash + afterTagChr + afterTag;\n\t\t\t\t\n\t\t\t\tif (this.app.isMobile && this.settings.mobileNotices) { new Notice ('Tag Buddy: ' + tag + ' converted to text.'); }\n\t\t\t\t// Setting: make this a setting to show notices on mobile\n\t\t\t\n\t\t\t} else if (((event.type == 'touchend') || this.settings.mobileTagSearch) || (this.ctrlCmdKey(event) && !this.settings.removeOnClick) || (!this.ctrlCmdKey(event) && this.settings.removeOnClick)) {\n\n\t\t\t\t// Remove tag (or child first, if exists)\n\n\t\t\t\tlet parentTag = '';\n\n\t\t\t\tif (tag.includes('/') && (this.settings.removeChildTagsFirst || (event.shiftKey && !this.settings.removeChildTagsFirst))) {\n\t\t\t\t\t\n\t\t\t\t\tlet parts = tag.split('/');\n\t\t\t\t\tconst removedChild = parts.pop();\n\t\t\t\t\tparentTag = parts.join('/');\n\t\t\t\t\t//newContent = beforeTag + (!beforeTag.endsWith(' ')?' ':'') + parentTag + (!afterTag.startsWith(' ')?' ':'') + afterTag;\n\t\t\t\t\tnewContent = beforeTag + (!beforeTag.endsWith(' ')?' ':'') + parentTag + afterTagChr + afterTag;\n\n\n\t\t\t\t\tif (this.app.isMobile && this.settings.mobileNotices) { new Notice ('Tag Buddy: \\'' + removedChild + '\\' removed from parent tag.'); }\n\t\t\t\t\n\t\t\t\t} else {\n\t\t\t\t\tnewContent = beforeTag + afterTag;\n\t\t\t\t\tif (this.app.isMobile && this.settings.mobileNotices) { new Notice ('Tag Buddy: ' + tag + ' removed.'); }\n\t\t\t\t}\n\t\t\t} \n\t\t\t\n\n\t\t\ttry {\n\t\t\t\n\t\t\t\t//await this.app.vault.modify(file, newContent);\n\n\n\t\t\t\tif (tagEl.getAttribute('type') == 'plugin-summary') {\n\n\n\t\t\t\t\tconst summaryEl = tagEl.closest('.tag-summary-paragraph');\n\t\t\t\t\tconst mdSource = summaryEl.getAttribute('md-source').trim();\n\t\t\t\t\t\n\t\t\t\t\tconst escapedText = this.escapeRegExp(mdSource);\n\t\t\t\t\tconst regex = new RegExp(escapedText, \"g\");  // The \"g\" flag means \"global\", so it will find all occurrences\n\t\t\t\t\tconst matches = fileContent.match(regex);\n\t\t\t\t\t\n\t\t\t\t\tif (matches && matches.length > 1) {\n\t\t\t\t\t    //console.log(`Found ${matches.length} occurrences of \"${pattern}\" in \"${subject}\".`);\n\t\t\t\t\t    new Notice ('\u26A0\uFE0F Can\\'t safely remove/edit tag:\\nSurrounding text repeated in source note.');\n\t\t\t\t\t    return;\n\t\t\t\t\t} else if ((matches && matches.length === 0) || !matches) {\n\t\t\t\t\t\tnew Notice ('\u26A0\uFE0F Can\\'t find tag in source note.\\n');\n\t\t\t\t\t    return;\n\t\t\t\t\t}\n\n\n\t\t\t\t\t// File safety checks\n\t\t\t\t\tif ((newContent == '' && !safeToEmptyFile) || this.contentChangedTooMuch(fileContentBackup, newContent, tag, 2)) {\n\t\t\t\t\t\t// Check if there was only one tag in the file, if so, don't restore backup;\n\t\t\t\t\t\tnew Notice('Tag Buddy: File change error.');\n\t\t\t\t\t\tnewContent = fileContentBackup;\n\t\t\t\t\t} else if (newContent == '' && safeToEmptyFile) {\n\t\t\t\t\t\tnew Notice('Tag Buddy: Tag removed. The note is empty.');\n\t\t\t\t\t}\n\n\t\t\t\t\tsetTimeout(async () => {\n\t\t\t\t\t\t\n\t\t\t\t\t\tconst tagParagraphEl = tagEl.closest('.tag-summary-paragraph');\n\t\t\t\t\t\t//console.log('this is the error')\n\t\t\t\t\t\tconst tagSummaryBlock = tagEl.closest('.tag-summary-block');\n\t\t\t\t\t\t\n\t\t\t\t\t\t//const tagsStr = tagSummaryBlock.getAttribute('codeblock-tags');\n\t\t\t\t\t\t//const tags = tagsStr ? tagsStr.split(',') : [];\n\t\t\t\t\t\t//const tagsIncludeStr = tagSummaryBlock.getAttribute('codeblock-tags-include');\n\t\t\t\t\t\t//const tagsInclude = tagsIncludeStr ? tagsIncludeStr.split(',') : [];\n\t\t\t\t\t\t//const tagsToCheck = tags.concat(tagsInclude);\n\t\t\t\t\t\tconst tagsToCheck = this.getTagsToCheckFromEl(tagSummaryBlock);\n\n\t\t\t\t\t\tconst tagsInContent = this.tagsInString(tagParagraphEl.innerText);\n\t\t\t\t\t\t//const tagCount = tagsInContent?.length;\n\t\t\t\t\t\t//const tagCount = this.countOccurrences(tagsToCheck, tagsInContent)\n\n\t\t\t\t\t\t//console.log('tags to check: ' + tagsToCheck)\n\t\t\t\t\t\t\n\n\t\t\t\t\t\tif (tagsToCheck.includes(tag)) {\n\t\t\t\t\t\t\t//let tagCount = this.tagsInString(tagParagraphEl.innerText, tag).length;\n\t\t\t\t\t\t\tconst tagCount = this.countOccurrences(tagsToCheck, tagsInContent)\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t// count all of the occurrences of tags to check against tags in this paragraph\n\t\t\t\t\t\t\t// not just the one tag\n\n\t\t\t\t\t\t\tif (tagCount >= 2) {\n\t\t\t\t\t\t\t\tthis.updateSummary(tagSummaryBlock); \n\t\t\t\t\t\t\t\t//this.updateSummaries(); // causes screen flicker\n\t\t\t\t\t\t\t    setTimeout(async () => { this.processTags(); }, 200);\n\t\t\t\t\t\t\t\t// this.refreshView(); // no need for this atm\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t//console.log('last one, will remove paragraph')\n\t\t\t\t\t\t\t\tconst notice = new Notice (tag + ' removed from paragraph.\\n\uD83D\uDD17 Open source note.', 5000);\n\t\t\t\t\t\t\t\tthis.removeElementWithAnimation(tagParagraphEl, () => {\n\t\t\t\t    \t\t\t\tsetTimeout(async () => { this.updateSummary(tagSummaryBlock); tagParagraphEl.remove(); }, 500);\n\t\t\t\t\t\t\t\t\t//this.updateSummaries(); // causes screen flicker\n\t\t\t\t\t\t\t    \tsetTimeout(async () => { this.processTags(); }, 800);\n\t\t\t\t\t\t\t\t\t// this.refreshView(); // no need for this atm\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t\tthis.registerDomEvent(notice.noticeEl, 'click', (e) => {\n\t\t\t\t\t\t\t \t \tthis.app.workspace.openLinkText(filePath, '');\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tthis.updateSummary(tagSummaryBlock); \n\t\t\t\t\t\t\t//this.updateSummaries(); // causes screen flicker\n\t\t\t\t\t\t    setTimeout(async () => { this.processTags(); }, 200);\n\t\t\t\t\t\t\t// this.refreshView(); // no need for this atm\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}, 200);\n\t\t\t\t} else {\n\t\t\t\t\tsetTimeout(async () => { this.processTags(); }, 50)\n\t\t\t\t}\n\n\n\t\t\t\tawait this.app.vault.modify(file, newContent);\n\n\n\t\t\t} catch (error) {\n\n\t\t\t\ttry {\n\n\t\t\t\t\tconst backupFileName = String(file.name.substring(0, file.name.indexOf('.md')) + ' BACKUP.md');\n\t\t\t\t\tthis.app.vault.create(backupFileName, fileContentBackup);\n\n\t\t\t\t\tnew Notice('\u26A0\uFE0F Tag/note editing error: ' + error.message + '\\n' + backupFileName + ' saved to vault root.');\n\t\t\t\t\n\t\t\t\t} catch (error) {\n\n\t\t\t\t\tnavigator.clipboard.writeText(fileContentBackup);\n\t\t\t\t\tnew Notice('\u26A0\uFE0F Tag/note editing error: ' + error.message + '\\nNote content copied to clipboard.');\n\n\t\t\t\t}\n\t\t\t} \n\t\t} else {\n\t\t\tthis.processTags();\n\t\t\tnew Notice('\u26A0\uFE0F Can\\'t identify tag location. Please try again.');\n\t\t}\n\t}\n\n\tgetTagsToCheckFromEl (tagSummaryEl):Array {\n\t\tconst tagsStr = tagSummaryEl.getAttribute('codeblock-tags');\n\t\tconst tags = tagsStr ? tagsStr.split(',') : [];\n\t\tconst tagsIncludeStr = tagSummaryEl.getAttribute('codeblock-tags-include');\n\t\tconst tagsInclude = tagsIncludeStr ? tagsIncludeStr.split(',') : [];\n\t\treturn tags.concat(tagsInclude);\n\t}\n\n\tupdateSummary (summaryEl) {\n\t\t//console.log('Update summary')\n\t\tconst summaryContainer = summaryEl; //tagEl.closest('.tag-summary-block');\n\t\tconst tagsStr = summaryContainer.getAttribute('codeblock-tags');\n\t\tconst tags = tagsStr ? tagsStr.split(',') : [];\n\n\t\tconst tagsIncludeStr = summaryContainer.getAttribute('codeblock-tags-include');\n\t\tconst tagsInclude = tagsIncludeStr ? tagsIncludeStr.split(',') : [];\n\n\t\tconst tagsExcludeStr = summaryContainer.getAttribute('codeblock-tags-exclude');\n\t\tconst tagsExclude = tagsExcludeStr ? tagsExcludeStr.split(',') : [];\n\n\t\tconst sectionsStr = summaryContainer.getAttribute('codeblock-sections');\n\t\tconst sections = sectionsStr ? sectionsStr.split(',') : [];\n\n\t\tconst max = Number(summaryContainer.getAttribute('codeblock-max'));\n\n\t\tconst mdSource = summaryContainer.getAttribute('codeblock-code');\n\n\t\t// Recreate summary after we've edited the file\n\t\tthis.createSummary(summaryContainer, tags, tagsInclude, tagsExclude, sections, max, '', mdSource);\n\n\t\t//setTimeout(async () => { this.processTags(); }, 200);\n\t}\n\n\t/*async updateSummariess () {\n\t\t//const activeFile = await this.app.workspace.getActiveFile();\n\t\t//const fileContent = await app.vault.read(activeFile);\n\t\tconst activeNoteContainer = await this.app.workspace.activeLeaf.containerEl;\n\t\tconst embeds = await activeNoteContainer.querySelectorAll('.tag-summary-block');\n\t\t//let embededTagFiles = [];\n\n\t\tembeds.forEach(async (embed) => {\n\t\t\tif (embed.classList.contains('tag-summary-block')) {\n\t\t\t\tthis.updateSummary (embed);\n\t\t\t}\n\t\t});\n\t}*/\n\n\tasync processTags () {\n\n\t\tif (this.settings.debugMode) console.log('Tag Buddy: Processing tags.');\n\t\tconst view = await this.app.workspace.getActiveViewOfType(MarkdownView);\n\t\tif (view) {\n\t\t\t//setTimeout(async () => { \n\t\t\tconst activeNoteContainer = await this.app.workspace.activeLeaf.containerEl;\n\t\t\t//console.log(activeNoteContainer)\n\t\t\tconst activeNoteReadingView = activeNoteContainer.querySelector('.markdown-reading-view');\n\t\t\tconst activeNoteEditView = activeNoteContainer.querySelector('.markdown-source-view');\n\t\t\t\n\t\t\t//console.log(activeNoteContainer)\n\t\t\t//const activeNoteContainer = await document.querySelector('.view-content');\n\t\t\t//}, 200)\n\t\t\t//setTimeout(async () => { // All these timeouts were for testing. Issues seems to be resolved now.\n\t\t\tconst activeFile = await this.app.workspace.getActiveFile();\n\t\t\tconst fileContent = await app.vault.read(activeFile);\n\t\t\tconst activeFileTagElements = await activeNoteContainer.querySelectorAll('.mod-active .tag:not(.markdown-embed .tag):not(.tag-summary-block .tag)');\n\n\t\t\t//setTimeout(async () => { console.log(activeFileTagElements)}, 1000)\n\t\t\tconst activeFileTags = await this.getMarkdownTags(activeFile, fileContent);\n\t\t\tif (activeFileTags.length > 0) this.assignMarkdownTags(activeFileTags, activeFileTagElements, 0, 'active');\n\t\t\t//this.processEmbeds(activeNoteContainer);\n\t\t\tthis.processEmbeds(activeNoteReadingView);\n\t\t\t//}, 500)\n\t\t}\n\t}\n\n\tasync getMarkdownTags (file, fileContent) {\n\t\t//console.log('getMarkdownTags')\n\t\tconst tagPositions = [];\n\t\tlet match;\n\t\t//const regex = /(?:^|\\s)#[^\\s#]+|```/g; // BUG: wrong match.index. matches the space before the tag.\n\t\t//const regex = /(?<=^|\\s)#[^\\s#]+|```/g // FIX. But still matching punctuation after\n\t\tconst regex = /(?<=^|\\s)(#[^\\s#.,;!?:]+)(?=[.,;!?:\\s]|$)|```/g  // matches punctuation after, but not included in the match\n\n\t\tlet insideCodeBlock = false;\n\n\t\twhile ((match = regex.exec(fileContent)) !== null) {\n\t\t    if (match[0].trim() === \"```\") {\n\t\t        insideCodeBlock = !insideCodeBlock; \n\t\t        continue;\n\t\t    }\n\t\t    \n\t\t    if (insideCodeBlock) continue;\n\n\t\t    const tag = match[0].trim();\n\t\t    // Look ahead from the current match and see if it's followed by ]]\n\t\t    if (fileContent.slice(match.index, match.index + tag.length + 2).endsWith(\"]]\")) {\n\t\t        continue; // Skip this match as it's part of a wikilink\n\t\t    }\n\t\t    tagPositions.push({tag:tag, index:match.index, source:file.name}); \n\t\t    //console.log(tagPositions[tagPositions.length-1])\n\t\t}\n\t\t//console.log('markdown tag count: ' + tagPositions.length)\n\t\t//console.log(tagPositions)\n\t\treturn tagPositions;\n\t}\n\n\tassignMarkdownTags (tagPositions:Array, tagElements, startIndex, type) {\n\t\t//console.log('------------------------------')\n\t\t//console.log(startIndex)\n\t\t//console.log(tagPositions)\n\t\tlet tagEl;\n\t\tconst tagElArray = Array.from(tagElements);\n\t\tlet tagElIndex = 0;\n\t\t//tagPositions.forEach(item => console.log(item.index, item.tag));\n\t\ttagPositions.forEach((tagPos, i) => {\n\t\t\tif (tagPositions[i].index >= startIndex) {\n\t\t\t\ttagEl = tagElArray[tagElIndex] as HTMLElement;\n\t\t\t\tif (tagEl) {\n\t\t\t\t\t//console.log(tagEl, tagPositions[i].tag, tagPositions[i].index);\n        \t\t\ttagEl.setAttribute('md-index', tagPositions[i].index);\n        \t\t\ttagEl.setAttribute('file-source', tagPositions[i].source);\n        \t\t\ttagEl.setAttribute('type', type);\n        \t\t\t//tagElIndex++;\n        \t\t} \n        \t\ttagElIndex++;\n    \t\t} \n\t\t}); \n\t\treturn tagElArray; //Array.from(tagElements); \n\t}\n\n\tasync processEmbeds (element, ids=['tag-summary-block', 'markdown-embed']) {\n \t\t//const embeds = await element.querySelectorAll('.mod-active .tag:not(.markdown-embed .tag):not(.tag-summary-block .tag)');\n\t\t//console.log('processEmbeds')\n\t\tconst embeds = await element.querySelectorAll('.tag-summary-block, .markdown-embed');\n\t\t//let embededTagFiles = [];\n\t\t//console.log(embeds)\n\t\tembeds.forEach(async (embed) => {\n\t\t\t//console.log(embed)\n\t\t\t//if (embed.classList.contains('tag-summary-block') && ids.includes('tag-summary-block')) {\n\t\t\tif (embed.classList.contains('tag-summary-block')) {\n\t\t\t\t//console.log('process summary')\n\t\t\t\tthis.processTagSummary(embed);\t\n\n\t\t\t//} else if (embed.classList.contains('markdown-embed') && ids.includes('markdown-embed')) {\n\t\t\t} else if (embed.classList.contains('markdown-embed')) {\n\n\t\t\t\tthis.processNativeEmbed(embed);\n\t\t\t\t\n\t\t\t\tif (Array.from(embed.querySelectorAll('.tag-summary-block')).length > 0) {\n\t\t\t\t\tthis.processTagSummary(embed);\n\t\t\t\t}\n\t\t\t\t\n\t\t\t} else {\n\t\t\t\t//new Notice('Tag Buddy: Tag embed in unsupported element.');\n\t\t\t\t// Handle this issue on click.\n\t\t\t}\n\t\t});\n\t\t//return embededTagFiles;\n\t}\n\n\tasync processNativeEmbed (embed) {\n\t\tconst linkElement = embed.getAttribute('src'); //this.findAncestor(clickedTag, 'span')\n\t\tlet filePath = embed.getAttribute('src');\n\t\tconst linkArray = filePath.split('#');\n\t\tfilePath = linkArray[0].trim() + '.md';\n\t\tconst file = await this.validateFilePath(filePath)\n\t\tif (file) {\n\t\t\tconst fileContent = await app.vault.read(file);\n\t\t\tconst embededTagFile = await this.getMarkdownTags(file, fileContent)\n\t\t\t//embededTagFiles.push(embededTagFile);\n\t\t\t\n\t\t\tconst tempComponent = new TempComponent();\n\t\t\tconst tempContainerHTML = createEl(\"div\");\n\t\t\t\n\t\t\tawait MarkdownRenderer.renderMarkdown(fileContent, tempContainerHTML, file.path, tempComponent);\n\t\t\t\n\t\t\t//const innerText = this.cleanString(embed.querySelector('.markdown-embed-content').innerText);\n\t\t\t//const startIndex = this.cleanString(tempContainerHTML.innerText).indexOf(innerText);\n\t\t\tconst innerText = embed.querySelector('.markdown-embed-content').innerText;\n\t\t\tconst startIndex = tempContainerHTML.innerText.indexOf(innerText);\n\t\t\t\n\t\t\tthis.assignMarkdownTags(embededTagFile, embed.querySelectorAll('.tag'), startIndex, 'native-embed');\n\t\t}\n\t}\n\n\tasync processTagSummary (embed) {\n\t\tlet summaryBlocks = embed.querySelectorAll('blockquote'); \n\t\tsummaryBlocks.forEach(async (block, index) => {\n\n\t\t\tconst filePath = block.getAttribute('file-source'); // linkElement.getAttribute('data-href')\n\t\t\tconst file = this.app.vault.getAbstractFileByPath(filePath);\n\t\t\tconst tempComponent = new TempComponent();\n\n\t\t\tif (file) {\n\t\t\t\tlet fileContent = await app.vault.read(file);\n\t\t\t\tconst embededTagFile = await this.getMarkdownTags(file, fileContent);\n\t\t\t\t\n\t\t\t\t// Create a temporty element block so we can match match text only content of this element with it's source note\n\t\t\t\tconst tempBlock = block.cloneNode(true);\n\t\t\t\t//tempBlock.querySelector('br')?.remove();\n\t\t\t\t//tempBlock.querySelector('strong')?.remove(); \n\t\t\t\ttempBlock.querySelector('.tagsummary-item-title')?.remove(); \n\t\t\t\ttempBlock.querySelector('.tagsummary-buttons')?.remove(); \n\t\t\t\t//const blockText = this.cleanString(tempBlock.innerText); // fuck this bug!\n\t\t\t\t//const startIndex = this.cleanString(fileContent).indexOf(blockText)\n\t\t\t\t\n\t\t\t\t/////\n\t\t\t\t// old way before we stored the MD paragraph in the html element\n\t\t\t\t//const markdownBlock = htmlToMarkdown(tempBlock).trim();\n\t\t\t\t/////\n\t\t\t\t// NEW WAY\n\t\t\t\tconst markdownBlock = block.getAttribute('md-source').trim();\n\n\n\t\t\t\t//fileContent = fileContent.replace(/\\s+/g, ' '); // whitespace normalization because the tag summary will have done this to the block\n\t\t\t\t// nope, can't do that because then the indexes will be off.\n\t\t\t\t\n\n\t\t\t\t//const blockText = markdownBlock; //tempBlock.innerText.trim();\n\t\t\t\tconst startIndex = fileContent.indexOf(markdownBlock);\n\t\t\t\t//const tempDom = createEl('div'); \n\t\t\t\t//await MarkdownRenderer.renderMarkdown(fileContent, tempDom, '', tempComponent);\n\t\t\t\t//const tempContent = tempDom.innerText\n\t\t\t\t//console.log('-----> ' + fileContent.indexOf('#tools2'))\n\t\t\t\t/*console.log(fileContent)\n\t\t\t\tconsole.log('----------------')\n\t\t\t\t//console.log(JSON.stringify(markdownBlock)) //console.log(blockText)\n\t\t\t\tconsole.log(markdownBlock)\n\t\t\t\tconsole.log('----------------')\n\t\t\t\tconsole.log(fileContent.indexOf(markdownBlock))*/\n\t\t\t\t// htmlToMarkdown(summaryContainer.innerHTML)\n\n\t\t\t\t//console.log(startIndex)\n\t\t\t\tthis.assignMarkdownTags(embededTagFile, block.querySelectorAll('.tag'), startIndex, 'plugin-summary');\n\t\t\t}\n\t\t});\t\t\n\t}\n\n\tasync summaryCodeBlockProcessor (source, el, ctx) {\n\t\t// Initialize tag list\n\t\tlet tags: string[] = Array();\n\t\tlet include: string[] = Array();\n\t\tlet exclude: string[] = Array();\n\t\tlet sections: string[] = Array();\n\t\tlet max: number = 50;\n\t\tconst maxPattern = /^\\s*max:\\s*(\\d+)\\s*$/;\n\t\tlet match;\n\n\t\t// Process rows inside codeblock\n\t\tconst rows = source.split(\"\\n\").filter((row) => row.length > 0);\n\t\trows.forEach((line) => {\n\t\t\t// Check if the line specifies the tags (OR)\n\t\t\tif (line.match(/^\\s*tags:[\\p{L}0-9_\\-/# ]+$/gu)) {\n\t\t\t\tconst content = line.replace(/^\\s*tags:/, \"\").trim();\n\n\t\t\t\t// Get the list of valid tags and assign them to the tags variable\n\t\t\t\tlet list = content.split(/\\s+/).map((tag) => tag.trim());\n\t\t\t\tlist = list.filter((tag) => {\n\t\t\t\t\tif (tag.match(/^#[\\p{L}]+[^#]*$/u)) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t\ttags = list;\n\t\t\t}\n\n\t\t\t// Check if the line specifies the tags to include (AND)\n\t\t\tif (line.match(/^\\s*include:[\\p{L}0-9_\\-/# ]+$/gu)) {\n\t\t\t\tconst content = line.replace(/^\\s*include:/, \"\").trim();\n\n\t\t\t\t// Get the list of valid tags and assign them to the include variable\n\t\t\t\tlet list = content.split(/\\s+/).map((tag) => tag.trim());\n\t\t\t\tlist = list.filter((tag) => {\n\t\t\t\t\tif (tag.match(/^#[\\p{L}]+[^#]*$/u)) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t\tinclude = list;\n\t\t\t}\n\n\t\t\t// Check if the line specifies the tags to exclude (NOT)\n\t\t\tif (line.match(/^\\s*exclude:[\\p{L}0-9_\\-/# ]+$/gu)) {\n\t\t\t\tconst content = line.replace(/^\\s*exclude:/, \"\").trim();\n\n\t\t\t\t// Get the list of valid tags and assign them to the exclude variable\n\t\t\t\tlet list = content.split(/\\s+/).map((tag) => tag.trim());\n\t\t\t\tlist = list.filter((tag) => {\n\t\t\t\t\tif (tag.match(/^#[\\p{L}]+[^#]*$/u)) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t\texclude = list;\n\t\t\t}\n\n\t\t\t// Check if the line specifies sections of a note\n\t\t\tif (line.match(/^\\s*sections:[\\p{L}0-9_\\-/#, ]+$/gu)) {\n\t\t\t\tconst content = line.replace(/^\\s*sections:/, \"\").trim();\n\t\t\t\t// Get the list of sections and assign them to the sections variable\n\t\t\t\tlet list = content.split(',').map((sec) => sec.trim());\n\t\t\t\tsections = list;\n\t\t\t}\n\n\t\t\t// Check if the line specifies max number of blocks to display\n\t\t\tmatch = line.match(maxPattern);\n\t\t\tif (match) {\n    \t\t\tmax = Math.min(50, Number(match[1]));\n\t\t\t}\n\t\t});\n\t\tconst codeBlock = '```tag-summary\\n'+source.trim()+'\\n```'\n\t\t// Create summary only if the user specified some tags\n\t\tif (tags.length > 0 || include.length > 0) {\n\t\t\tawait this.createSummary(el, tags, include, exclude, sections, max, ctx.sourcePath, codeBlock);\n\t\t} else {\n\t\t\tthis.createEmptySummary(el, tags?tags:[], include?include:[], exclude?exclude:[], sections?sections:[], max?max:[], ctx.sourcePath?ctx.sourcePath:'', codeBlock);\n\t\t} \n\t}; \n\n\tcreateEmptySummary(element: HTMLElement, tags: String[], include: string[], exclude: string[], sections: string[], max: number, fileCtx: string, mdSource:string) {\n\t\tconst container = createEl('div');\n\t\t//const buttonContainer = createEl('div');\n\t\t//buttonContainer.setAttribute('class', 'tagsummary-buttons');\n\t\tconst textDiv = createEl(\"blockquote\");\n\t\t//container.setAttribute('class', 'tagsummary-notags');\n\t\ttextDiv.innerHTML = \"There are no files with tagged paragraphs that match the tags:<br>\" + (tags.length>0?tags.join(', '):\"No tags specified.\") + \"<br>\";\n\t\tcontainer.appendChild(textDiv);\n\t\t//const view = this.app.workspace.getActiveViewOfType(MarkdownView);\n\t\t//const switchModeButton = this.makeSwitchToEditingButton (view);\n\t\t//container.appendChild(switchModeButton);\n\t\t//console.log(include.length)\n\t\tcontainer.setAttribute('codeblock-tags', ((tags.length>0)?tags.join(','):''));\n\t\tcontainer.setAttribute('codeblock-tags-include', (include?include.join(','):''));\n\t\tcontainer.setAttribute('codeblock-tags-exclude', (exclude?exclude.join(','):''));\n\t\tcontainer.setAttribute('codeblock-sections', (sections?sections.join(','):''));\n\t\tcontainer.setAttribute('codeblock-max', max);\n\t\tcontainer.setAttribute('codeblock-code', mdSource);\n\t\t//if (this.settings.debugMode) \n\t\tcontainer.appendChild(this.makeSummaryRefreshButton(container));;\n\n\t\telement.replaceWith(container);\n\t}\n\n\tasync createSummary(\n\t\telement: HTMLElement, \n\t\ttags: string[], \n\t\tinclude: string[], \n\t\texclude: string[], \n\t\tsections: string[],\n\t\tmax: number, \n\t\tfileCtx: string,\n\t\tmdSource:string) {\n\t\t\n\t\tconst activeFile = await this.app.workspace.getActiveFile();\n\t\tconst validTags = tags.concat(include); // All the tags selected by the user\n\t\tconst tempComponent = new TempComponent();\n\t\tconst summaryContainer = createEl('div');\n\t\t\n\t\tsummaryContainer.setAttribute('class', 'tag-summary-block');\n\t\t\n\t\t// Get files\n\t\tlet listFiles = this.app.vault.getMarkdownFiles();\n\n\t\t// Filter files\n\t\tlistFiles = listFiles.filter((file) => {\n\t\t\t// Remove files that do not contain the tags selected by the user\n\t\t\tconst cache = app.metadataCache.getFileCache(file);\n\t\t\tconst tagsInFile = getAllTags(cache);\n\n\t\t\tif (validTags.some((value) => tagsInFile.includes(value))) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\treturn false;\n        });\n\n\t\t// Sort files alphabetically\n\t\t// change to sort by last modified?\n\t\tlistFiles = listFiles.sort((file1, file2) => {\n\t\t\tif (file1.path < file2.path) {\n\t\t\t\treturn -1;\n\t\t\t} else if (file1.path > file2.path) {\n\t\t\t\treturn 1;\n\t\t\t} else {\n\t\t\t\treturn 0;\n\t\t\t}\n\t\t});\n\n\t\t// Get files content\n\t\tlet listContents: [TFile, string][] = await this.readFiles(listFiles);\n\t\tlet count = 0;\n\n\t\t// Create summary\n\t\tlet summary: string = \"\";\n\t\tlistContents.forEach((item) => {\n\t\t\t//if (count >= max) return;\n\n\t\t\t// Get files name\n\t\t\tconst fileName = item[0].name.replace(/.md$/g, \"\");\n\t\t\tconst filePath = item[0].path;\n\t\t\t//console.log(activeFile)\n\t\t\t// Do not add this item if it's in the same file we're creating the summary\n\t\t\t// should filter this file out earlier\n\t\t\tif (activeFile) {\n\t\t\t\tif (activeFile.name == item[0].name) return;\n\t\t\t}\n\n\t\t\t// Get paragraphs\n\t\t\tlet listParagraphs: string[] = Array();\n\t\t\tconst blocks = item[1].split(/\\n\\s*\\n/).filter((row) => row.trim().length > 0);\n\n\t\t\t// Get list items\n\t\t\tblocks.forEach((paragraph) => {\n\t\t\t\t\n\t\t\t\t// Check if the paragraph is another plugin\n\t\t\t\tlet valid = false;\n\t\t\t\tlet listTags = paragraph.match(/#[\\p{L}0-9_\\-/#]+/gu);\n\t\t\t\t\n\t\t\t\tif (listTags != null && listTags.length > 0) {\n\t\t\t\t\t//console.log('paragraph.contains(\"```\") : ' + paragraph.contains(\"```\"))\n\t\t\t\t\tif (!paragraph.contains(\"```\")) {\n\t\t\t\t\t\t//console.log(include)\n\t\t\t\t\t\tvalid = this.isValidText(listTags, tags, include, exclude);\n\t\t\t\t\t\t//console.log(valid)\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tif (valid) {\n\t\t\t\t\t// Add paragraphs and the items of a list\n\t\t\t\t\tlet listItems: string[] = Array();\n\t\t\t\t\tlet itemText = \"\";\n\n\t\t\t\t\tparagraph.split('\\n\\s*\\n').forEach((line) => {\n\t\t\t\t\t\tif (count >= max) return;\n\t\t\t\t\t\tlet isList = false;\n\t\t\t\t\t\tisList = line.search(/(\\s*[\\-\\+\\*]){1}|([0-9]\\.){1}\\s+/) != -1\n\n\t\t\t\t\t\tif (!isList) {\n\t\t\t\t\t\t\t// Add normal paragraphs\n\t\t\t\t\t\t\tlistParagraphs.push(line);\n\t\t\t\t\t\t\titemText = \"\";\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tline.split('\\n').forEach((itemLine) => {\n\t\t\t\t\t\t\t\t// Get the item's level\n\t\t\t\t\t\t\t\tlet level = 0;\n\t\t\t\t\t\t\t\tconst endIndex = itemLine.search(/[\\-\\+\\*]{1}|([0-9]\\.){1}\\s+/);\n\t\t\t\t\t\t\t\tconst tabText = itemLine.slice(0, endIndex);\n\t\t\t\t\t\t\t\tconst tabs = tabText.match(/\\t/g);\n\t\t\t\t\t\t\t\tif (tabs) {\n\t\t\t\t\t\t\t\t\tlevel = tabs.length;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t// Get items tree\n\t\t\t\t\t\t\t\tif (level == 0) {\n\t\t\t\t\t\t\t\t\tif (itemText != \"\") {\n\t\t\t\t\t\t\t\t\t\tlistItems.push(itemText);\n\t\t\t\t\t\t\t\t\t\titemText = \"\";\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\titemText = \"\" + itemText.concat(itemLine + \"\\n\");\n\t\t\t\t\t\t\t\t\t// Removed include children setting\n\t\t\t\t\t\t\t\t} else if (level > 0 && itemText != \"\") {\n\t\t\t\t\t\t\t\t\titemText = itemText.concat(itemLine + \"\\n\");\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t}\n\t\t\t\t\t\tcount++\n\t\t\t\t\t});\n\n\t\t\t\t\tif (itemText != \"\") {\n\t\t\t\t\t\tlistItems.push(itemText);\n\t\t\t\t\t\titemText = \"\";\n\t\t\t\t\t}\n\n\t\t\t\t\t// Check tags on the items\n\t\t\t\t\tlistItems.forEach((line) => {\n\t\t\t\t\t\tlistTags = line.match(/#[\\p{L}0-9_\\-/#]+/gu);\n\t\t\t\t\t\tif (listTags != null && listTags.length > 0) {\n\t\t\t\t\t\t\tif (this.isValidText(listTags, tags, include, exclude)) {\n\t\t\t\t\t\t\t\tlistParagraphs.push(line);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\t\n\t\t\t})\n\n\t\t\t// Process each block of text\n\t\t\tlistParagraphs.forEach(async(paragraph) => {\n\t\t\t\t// Restore newline at the end\n\t\t\t\tparagraph += \"\\n\";\n\t\t\t\tvar regex = new RegExp;\n\n\t\t\t\t// Check which tag matches in this paragraph.\n\t\t\t\tvar tagText = new String;\n\t\t\t\tvar tagSection = null;\n\t\t\t\ttags.forEach((tag) => {\n\t\t\t\t\ttagText = tag.replace('#', '\\\\#');\n\t\t\t\t\tregex = new RegExp(`${tagText}(\\\\W|$)`, 'g');\n              \t\tif (paragraph.match(regex) != null) { \n              \t\t\ttagSection = tag\n              \t\t} \n            \t});\n          \t\t\n          \t\tconst buttonContainer = createEl('div');\n          \t\tbuttonContainer.setAttribute('class', 'tagsummary-buttons')\n          \t\tconst paragraphEl = createEl(\"blockquote\");\n\t\t\t\tparagraphEl.setAttribute('file-source', filePath);\n\t\t\t\tparagraphEl.setAttribute('class', 'tag-summary-paragraph');\n\n\t\t\t\t////////////////////////////////////////////////////////////////\n\t\t\t\t//  MESSY! Lots of refactoring to be done in this function\n\t\t\t\t////////////////////////////////////////////////////////////////\n\n\t\t\t\t// Add link to original note. Tag Buddy added deep linking.\n\t\t\t\tconst blockLink = paragraph.match(/\\^[\\p{L}0-9_\\-/^]+/gu); \n\t\t\t\tlet link;\n\t\t\t\t//console.log(filePath, fileName)\n        \t\tif (blockLink) { \n        \t\t\t//paragraph = \"**[[\" + filePath + \"#\" + blockLink + \"|\" + fileName + \"]]**\" + paragraph; \n        \t\t\tlink = '[[' + filePath + '#' + blockLink + '|' + fileName + ']]';\n\n        \t\t\t//if (this.app.plugins.getPlugin('quickadd')) {\n\t\t\t\t\t\tlet count = 0;\n\t\t\t\t\t\tsections.forEach((sec) => {\n\t\t\t\t\t\t\tif (count++ > 3) return; // limit to 4 section buttons for now, for space.\n\t\t\t\t\t\t\t//buttonContainer.appendChild(this.makeCopyToButton (paragraph, sec, paragraphEl, tagSection, (filePath + '#' + blockLink)));\n\t\t\t\t\t\t\tbuttonContainer.appendChild(this.makeCopyToButton (paragraph, sec, paragraphEl, tags, (filePath + '#' + blockLink), paragraphEl, summaryContainer));\n\t\t\t\t\t\t});\n\t\t\t\t\t//}\n\t\t\t\t\tif (this.settings.tagSummaryBlockButtons) {\n\t\t\t\t\t\tbuttonContainer.appendChild(this.makeCopyButton(paragraph.trim()));\n        \t\t\t\tbuttonContainer.appendChild(this.makeRemoveTagButton(paragraphEl, tagSection, (filePath + '#' + blockLink)));\n        \t\t\t}\n\n        \t\t} else { \n        \t\t\t//paragraph = \"**[[\" + filePath + \"|\" + fileName + \"]]**\" + paragraph; \n        \t\t\tlink = '[[' + filePath + '|' + fileName + ']]';\n\n        \t\t\t//if (this.app.plugins.getPlugin('quickadd')) {\n\t\t\t\t\t\tlet count = 0;\n\t\t\t\t\t\tsections.forEach((sec) => {\n\t\t\t\t\t\t\tif (count++ > 3) return; // limit to 4 section buttons for now, for space.\n\t\t\t\t\t\t\t//if (this.settings.tagSummaryBlockButtons) buttonContainer.appendChild(this.makeCopyToButton (paragraph, sec, paragraphEl, tagSection, filePath));\n\t\t\t\t\t\t\tif (this.settings.tagSummaryBlockButtons) buttonContainer.appendChild(this.makeCopyToButton (paragraph, sec, paragraphEl, tags, filePath, paragraphEl, summaryContainer));\n\t\t\t\t\t\t});\n\t\t\t\t\t//}\n\t\t\t\t\tif (this.settings.tagSummaryBlockButtons) {\n\t\t\t\t\t\tbuttonContainer.appendChild(this.makeCopyButton(paragraph.trim()));\n        \t\t\t\tbuttonContainer.appendChild(this.makeRemoveTagButton(paragraphEl, tagSection, filePath));\n        \t\t\t}\n        \t\t}\n        \t\t//console.log('MD paragraph:\\n' + paragraph)\n        \t\tconst mdParagraph = paragraph;\n        \t\tparagraph = '**' + link + '**\\n' + paragraph;\n            \t//paragraph += \"\\n\";\n          \t\tsummary += paragraph + '\\n'; \n\n          \t\t//const tempEl = await createEl('div');\n          \t\t//await MarkdownRenderer.renderMarkdown(paragraph, tempEl,'', tempComponent);\n          \t\t//await MarkdownRenderer.renderMarkdown(paragraph, paragraphEl, this.app.workspace.getActiveFile()?.path, tempComponent);\n          \t\t//await MarkdownRenderer.renderMarkdown(paragraph, paragraphEl, '', tempComponent);\n          \t\tawait MarkdownRenderer.renderMarkdown(paragraph, paragraphEl, '', tempComponent);\n          \t\t//console.log(paragraph);\n          \t\t//console.log('-------------------------')\n          \t\t//console.log(paragraphEl.innerHTML)\n\n          \t\tconst titleEl = createEl('span');\n          \t\ttitleEl.setAttribute('class', 'tagsummary-item-title');\n          \t\ttitleEl.appendChild(paragraphEl.querySelector('strong').cloneNode(true))\n          \t\tif (this.settings.tagSummaryBlockButtons) paragraphEl.appendChild(buttonContainer);\n          \t\tparagraphEl.querySelector('strong').replaceWith(titleEl)\n          \t\tparagraphEl.setAttribute('md-source', mdParagraph)\n\n          \t\tsummaryContainer.appendChild(paragraphEl);\n\t\t\t});\n\t\t\t//count++\n\t\t});\n\t\n\t\t\n\t\t// Add Summary\n\t\tif (summary != \"\") {\n\t\t\tsetTimeout(async () => { \n\t\t\t\tif (this.settings.showSummaryButtons) {\n\t\t\t\t\tsummaryContainer.appendChild(this.makeSummaryRefreshButton(summaryContainer));\n\t        \t\tsummaryContainer.appendChild(this.makeCopySummaryButton(summary));\n\t        \t\tsummaryContainer.appendChild(this.makeSummaryNoteButton(summary, tags));\n\t        \t\tsummaryContainer.appendChild(this.makeBakeButton(summary, summaryContainer, activeFile.path));\n\t        \t\t// When refactoring, we should have a summary object that stores everything about it. \n\t        \t\t// That will help with making undo\n\t        \t\t// What about for native embeds\n\t        \t\tsummaryContainer.appendChild(createEl('br')); \n\t\t\t\t} \n\t\t\t\tsummaryContainer.appendChild(createEl('hr')); \n\t\t\t}, 0);\n\t\t\tsummaryContainer.setAttribute('codeblock-tags', tags.join(','));\n\t\t\tsummaryContainer.setAttribute('codeblock-tags-include', ((include.length>0)?include.join(','):''));\n\t\t\tsummaryContainer.setAttribute('codeblock-tags-exclude', ((exclude.length>0)?exclude.join(','):''));\n\t\t\tsummaryContainer.setAttribute('codeblock-sections', ((sections.length>0)?sections.join(','):''));\n\t\t\tsummaryContainer.setAttribute('codeblock-max', max);\n\t\t\tsummaryContainer.setAttribute('codeblock-code', mdSource);\n\n\t\t\t// await MarkdownRenderer.renderMarkdown(htmlToMarkdown(summaryContainer.innerHTML), summaryContainer, '', tempComponent);\n\t\t\telement.replaceWith(summaryContainer);\n\t\t} else {\n\t\t\t//this.createEmptySummary(element, tags, include, exclude);\n\t\t\tthis.createEmptySummary(element, tags?tags:[], include?include:[], exclude?exclude:[], sections?sections:[], max?max:[], '', mdSource);\n\t\t}\n\t}\n\n\t/*makeSwitchToEditingButton (view){\n\t\tconst button = this.makeButton ('Edit code block in edit-mode', async(e) => { \n\t\t\te.stopPropagation();\n\t\t\tconst view = await this.app.workspace.getActiveViewOfType(MarkdownView);\n\t\t\tif (view.getMode() == 'preview') {\n      \t\t\tlet curState = view.getState();\n      \t\t\tcurState.mode = 'source';\n      \t\t\tview.setState(curState);\n    \t\t}\n\t\t});\n\t\tbutton.title = 'Switch to edit mode';\n\t\treturn button;\n\t}*/\n\n\tmakeCopySummaryButton (summaryMd:string) {\n\t\tconst button = this.makeButton (' \u274F  ', (e) => { \n\t\t\te.stopPropagation();\n\t\t\tnavigator.clipboard.writeText(summaryMd);\n\t\t\tnew Notice ('Summary copied to clipboard.');\n\t\t});\n\t\tbutton.title = 'Copy summary';\n\t\treturn button;\n\t}\n\n\tmakeSummaryNoteButton (summaryMd:string, tags:Array) {\n\t\tconst button = this.makeButton ('Note', (e) => { \n\t\t\te.stopPropagation();\n\t\t\tconst newNoteObj = this.fileObjFromTags(tags);\n\t\t\tlet fileContent = '## ' + newNoteObj.title + '\\n\\n' + summaryMd;\n\t\t\tconst fileName = this.getActiveFileFolder()+newNoteObj.fileName;\n\t\t\tconst file = this.app.vault.getAbstractFileByPath(fileName);\n\t\t\tlet notice;\n\n\t\t\ttags.forEach ((tag) => {\n\t\t\t\t//fileContent = this.removeTagFromString(fileContent, tag);\n\t\t\t\tfileContent = this.replaceTextInString (tag, fileContent, tag.substring(1), true)\n\t\t\t\t//replaceTextInString (replaceText, sourceText, newText, all:boolean=false) \n\t\t\t});\n\t\t\t//console.log(fileContent)\n\t\t\tif (file instanceof TFile) {\n\t\t\t\t//await leaf.openFile(file, {active: newFolder.focused});\n\t\t\t\tnotice = new Notice ('\u26A0\uFE0F Note already exists.\\nClick here to overwrite.', 5000);\n\t\t\t\tthis.registerDomEvent(notice.noticeEl, 'click', (e) => {\n\t\t\t\t\tthis.app.vault.modify(file, fileContent);\n\t\t\t\t\tnotice = new Notice ('Note updated.\\n\uD83D\uDD17 Open note.', 5000);\n\t\t\t\t\tthis.registerDomEvent(notice.noticeEl, 'click', (e) => {\n\t\t\t\t\t\tthis.app.workspace.openLinkText(fileName, '');\n\t\t\t\t\t});\n\t\t\t\t});\n\t\t\t} else if (!file) {\n\t\t\t\tthis.app.vault.create(fileName, fileContent);\n\t\t\t\tconst notice = new Notice ('Tag Buddy: Summary note created. \uD83D\uDCDC\\n\uD83D\uDD17 Open note.');\n\t\t\t\tthis.registerDomEvent(notice.noticeEl, 'click', (e) => {\n\t\t\t\t\tthis.app.workspace.openLinkText(newNoteObj.fileName, '');\n\t\t\t\t});\n\t\t\t}\n\t\t});\n\t\tbutton.title = 'Create note from summary';\n\t\treturn button;\n\t}\n\n\tfileObjFromTags(tags:Array):Object {\n\t    // Remove hashes and split tags into an array\n\t    let tagsArray = tags.map(tag => tag.replace(/#/g, '').toLowerCase());\n\n\t    // Filter out duplicates\n\t    tagsArray = tagsArray.filter((tag, index, self) => self.indexOf(tag) === index);\n\n\t    // Construct the file name\n\t    const tagsPart = tagsArray.join('+');\n\t    const currentDate = new Date();\n\t    const datePart = currentDate.getDate().toString().padStart(2, '0') + '-' +\n\t                     (currentDate.getMonth() + 1).toString().padStart(2, '0') + '-' +\n\t                     currentDate.getFullYear().toString().slice(-2);\n\t    const fileName = `Tag Summary (${tagsPart}) (${datePart}).md`;\n\n\t    // Construct the title\n\t    const titleTagsPart = tagsArray.map(tag => tag.charAt(0).toUpperCase() + tag.slice(1)).join(' + ');\n\t    const title = `${titleTagsPart} Tag Summary`;\n\n\t    // Return the object with fileName and title properties\n\t    return {\n\t        fileName: fileName,\n\t        title: title\n\t    };\n\t}\n\n\tgetActiveFileFolder() {\n\t\tconst activeFile = app.workspace.activeLeaf.view.file;\n\t    if (!activeFile) return null;\n\n\t    // Determine the correct path separator\n\t    const pathSeparator = activeFile.path.includes('\\\\') ? '\\\\' : '/';\n\n\t    const pathParts = activeFile.path.split(pathSeparator);\n\t    pathParts.pop();  // Remove the file name part\n\t    let folderPath = pathParts.join(pathSeparator);\n\n\t    // Ensure the folder path ends with the correct path separator\n\t    if (!folderPath.endsWith(pathSeparator)) {\n\t        folderPath += pathSeparator;\n\t    }\n\n\t    return folderPath;\n\t}\n\n\tmakeSummaryRefreshButton (summaryEl) {\t\n\t\tconst button = this.makeButton (' \u21BA  ', (e) => { \n\t\t\te.stopPropagation();\n\t\t\tthis.updateSummary(summaryEl);\n\t\t\tnew Notice ('Tag Summary updated');\n\t\t\tsetTimeout(async () => { this.processTags(); }, 10);\n\t\t});\n\t\tbutton.title = 'Refresh Tag Summary';\n\t\treturn button;\n\t}\n\n\tmakeCopyToButton (content, section, paragraph, tags:Array, filePath, paragraphEl, summaryEl) {\n\t\t//const quickAddPlugin = this.app.plugins.plugins.quickadd.api; // need to check if this plugin is installed. and settings.\n\t\tconst buttonLabel = (' \u274F   ' + this.truncateStringAtWord(section, 16));\n\t\tconst button = this.makeButton (buttonLabel, async(e) => { \n\t\t\te.stopPropagation();\n\n\t\t\tlet newContent = content;\n\t\t\tconst prefix = this.settings.taggedParagraphCopyPrefix;\n\n\t\t\tif (this.ctrlCmdKey(e)) {\n\t\t\t\ttags.forEach((tag, i) => {\n\t\t\t\t\tnewContent = this.removeTagFromString(newContent, tag).trim();\n\t\t\t\t});\n\t\t\t} \n\n\t\t\t//const newContent = prefix + (this.ctrlCmdKey(e) ? this.removeTagFromString(content, tag) : content).trim();\n\t\t\tconst copySuccess = this.copyTextToSection(prefix + newContent, section, filePath);\n\t\t\t//quickAddPlugin.executeChoice('Copy To Section', {section:sectionElObj.md, content:(this.removeTagFromString(contentAsList, tag)+'\\n')});\n\n\t\t\tif (copySuccess) {\n\t\t\t\tif (this.ctrlCmdKey(e) && e.shiftKey) {\n\t\t\t\t\t\n\t\t\t\t\tconst file = this.app.vault.getAbstractFileByPath(filePath);\n\t\t\t\t\tlet fileContent = await this.app.vault.read(file);\n\t\t\t\t\tfileContent = fileContent.trim();\n\t\t\t\t\t\n\t\t\t\t\t//console.log(fileContent);\n\t\t\t\t\t//console.log('------------------------')\n\t\t\t\t\tconst newFileContent = this.replaceTextInString (content.trim(), fileContent, newContent).trim();\n\t\t\t\t\t//console.log(fileContent.indexOf(content.trim()));\n\t\t\t\t\t//console.log(newFileContent)\n\t\t\t\t\t//\n\t\t\t\t\tif (fileContent != newFileContent) {\n\t\t\t\t\t\t\n\t\t\t\t\t\tthis.app.vault.modify(file, newFileContent);\n\n\t\t\t\t\t\tconst notice = new Notice ('Paragraph moved to ' + section +'.\\n\uD83D\uDD17 Open source note.', 5000);\n\n\t\t\t\t\t\tthis.removeElementWithAnimation(paragraphEl, () => {\n\t\t    \t\t\t\tsetTimeout(async () => { this.updateSummary(summaryEl); paragraphEl.remove(); }, 500);\t\t\t\t\t\t\n\t\t\t\t\t    \tsetTimeout(async () => { this.processTags(); }, 800);\n\t\t\t\t\t\t});\n\t\t\t\t\t\tthis.registerDomEvent(notice.noticeEl, 'click', (e) => {\n\t\t\t\t\t\t\tthis.app.workspace.openLinkText(filePath, '');\n\t\t \t\t\t\t});\n\t\t\t\t\t} else {\n\t\t\t\t\t\tnew Notice ('Tag Buddy: Paragraph copied to ' + section + '.\\nBut can\\'t update source file.');\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t} else {\n\t\t\t\t\tnew Notice ('Tag Buddy: Paragraph copied to ' + section + '.');\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\t// errors currently from from the copy to. Will refactor.\n\t\t\t}\n\n\t\t});\n\n\t\tbutton.title = 'Copy paragraph to ' + section + '.\\n'+ this.ctrlCmdStr() + '+CLICK to remove tag(s) then copy.\\n';\n\t\tbutton.title += 'SHIFT+' + this.ctrlCmdStr() + '+CLICK to remove tags from source note paragraph.'\n\t\treturn button;\n\t}\n\n\tmakeBakeButton (summaryMd, summaryEl, filePath) {\t\n\t\tconst button = this.makeButton ('Bake', async(e) => { \n\t\t\te.stopPropagation();\n\t\t\tconst mdSource = summaryEl.getAttribute('codeblock-code');\n\t\t\tif (mdSource) {\n\t\t\t\t//console.log(mdSource)\n\t\t\t\t// active file\n\t\t\t\tconst file = this.app.vault.getAbstractFileByPath(filePath);\n\t\t\t\tconst fileContent = await this.app.vault.read(file);\n\t\t\t\t// replace this mdSource in active file\n\t\t\t\tconst newFileContent = this.replaceTextInString (mdSource, fileContent, summaryMd)\n\t\t\t\t//console.log(newFileContent)\n\t\t\t\t// save the active note\n\t\t\t\tthis.app.vault.modify(file, newFileContent);\n\n\t\t\t\tconst notice = new Notice ('Tag summary flattened to active note.');\n\t\t\t\t//notice.noticeEl.style.top = '500px';\n\t\t\t} else {\n\t\t\t\tnew Notice ('\u26A0\uFE0F Tag Buddy: Can\\t find code block source. This is a BUG.');\n\t\t\t}\n\t\t});\n\t\tbutton.title = 'Flatten summary (replaces code block).';\n\t\treturn button;\n\t}\n\n\tmakeCopyButton (content) {\t\n\t\tconst button = this.makeButton (' \u274F ', (e) => { \n\t\t\te.stopPropagation();\n\t\t\tnavigator.clipboard.writeText(content);\n\t\t\tconst notice = new Notice ('Tag Buddy: Copied to clipboard.');\n\t\t\t//notice.noticeEl.style.top = '500px';\n\t\t});\n\t\tbutton.title = 'Copy paragraph';\n\t\treturn button;\n\t}\n\n\tctrlCmdStr () {\n\t\tconst isMac = (navigator.platform.toUpperCase().indexOf('MAC') >= 0);\n\t\tif (isMac) return 'CMD';\n\t\telse return 'CTRL';\n\t}\n\n\t/*tagsInString (string:string, tag:string=''):Array {\n\t\tconst regex = new RegExp(tag.replace(/\\//g, '\\\\/') + \"(?![\\\\w\\\\/\\\\#])\", \"g\");\n\t\tconst matches = string.match(regex);\n\t\tconsole.log(matches)\n\t\treturn matches || []; //matches ? matches.length : 0;\n\t}*/\n\ttagsInString(string: string, tag?: string): string[] {\n\t    let regex;\n\n\t    if (tag) {\n\t        regex = new RegExp(tag.replace(/\\//g, '\\\\/') + \"(?![\\\\w\\\\/\\\\#])\", \"g\");\n\t    } else {\n\t        // Match any tag-like pattern starting with '#'\n\t        regex = /#(\\w+)(?![\\w\\/#])/g;\n\t    }\n\n\t    const matches = string.match(regex);\n\t    return matches || [];\n\t}\n\n\tcountOccurrences(summaryTags, contentTags) {\n\t    let count = 0;\n\t    //console.log (summaryTags, contentTags);\n\t    for (let tag of summaryTags) {\n\t        count += contentTags.filter(item => item === tag).length;\n\t    }\n\n\t    return count;\n\t}\n\n\tmakeRemoveTagButton (paragraphEl, tag, filePath) {\n\t\tconst button = this.makeButton (' \u2317\u02E3 ', (e) => { \n\t\t\te.stopPropagation();\n\n\t\t\t//const tagsToCheck = this.getTagsToCheckFromEl(paragraphEl.closest('.tag-summary-block'));\n\t\t\t//const tagsInContent = this.tagsInString(paragraphEl.innerText);\n\t\t\t//const tagCount = tagsInContent?.length;\n\t\t\t//const tagCount = this.countOccurrences(tagsToCheck, tagsInContent)\n\n\t\t\t//console.log('summary tags left: ' + tagCount)\n\n\t\t\tconst tagEl = this.getTagElement(paragraphEl, tag);\n\t\t\tthis.editTag(tagEl);\n\t\t\t/*if (tagCount >= 2 ) {\n\t\t\t\t//console.log('more than one left')\n    \t\t\tthis.editTag(tagEl);\n\t\t\t} else {\n\t\t\t\t//console.log('last one, will remove paragraph')\n\t\t\t\tconst notice = new Notice ('\uD83D\uDD16 ' + tag + ' removed from paragraph.\\n\uD83D\uDD17 Open source note.', 5000);\n\t\t\t\tthis.removeElementWithAnimation(paragraphEl, () => {\n    \t\t\t\tthis.editTag(tagEl);\n\t\t\t\t});\n\t\t\t\tthis.registerDomEvent(notice.noticeEl, 'click', (e) => {\n\t\t\t \t \tthis.app.workspace.openLinkText(filePath, '');\n\t\t\t\t});\n\t\t\t}*/\n\t\t});\n\t\tbutton.title = 'Remove ' + tag + ' from paragraph (and from this summary).';\n\t\treturn button;\n\t}\n\n\tremoveElementWithAnimation(el, callback) {\n\t  // Get the actual height of the element\n\t  const height = el.offsetHeight;\n\n\t  // Set height to the current value for CSS transition\n\t  el.style.height = `${height}px`;\n\n\t  // Allow the browser to update, then set to 0 to trigger the transition\n\t  //setTimeout(() => { el.style.height = '0px'; }, 0);\n\t  setTimeout(() => {\n        el.style.height = '0px';\n        el.style.opacity = '0';\n        el.style.margin = '0';\n        el.style.padding = '0';\n    \t}, 0);\n\t  \n\t  el.addEventListener('transitionend', function onEnd() {\n    \t\tel.removeEventListener('transitionend', onEnd);\n    \t\tcallback();\n\t    \t//setTimeout(() => { el.remove(); }, 10); // remove in the callback\n\t  });\n\t}\n\n\tmakeButton (lable, clickFn, classId='tagsummary-button') {\n\t\tconst button = document.createElement('button');\n\t    button.innerText = lable;\n\t    button.className = classId;\n\t    this.registerDomEvent(button, 'click', clickFn.bind(this));\n\t    return button;\n\t}\n\n\tgetMarkdownHeadings(bodyLines: string[]): Heading[] {\n\t\tconst headers: Heading[] = [];\n\t\tlet accumulatedIndex = 0;\n\n\t\tbodyLines.forEach((line, index) => {\n\t\t\tconst match = line.match(/^(#+)[\\s]?(.*)$/);\n\n\t\t\tif (match) {\n\t\t\t\theaders.push({\n\t\t\t\t\tfullText: match[0],\n\t\t\t\t\tlevel: match[1].length,\n\t\t\t\t\ttext: match[2],\n\t\t\t\t\tline: index,\n\t\t\t\t\tstartIndex: accumulatedIndex,\n\t        \t\tendIndex: (accumulatedIndex + match[0].length - 1)\n\t\t\t\t});\n\t\t\t}\n\t\t\taccumulatedIndex += line.length + 1;\n\t\t});\n\n\t\treturn headers;\n\t}\n\n\tgetLinesInString(input: string) {\n\t\tconst lines: string[] = [];\n\t\tlet tempString = input;\n\n\t\twhile (tempString.includes(\"\\n\")) {\n\t\t\tconst lineEndIndex = tempString.indexOf(\"\\n\");\n\t\t\tlines.push(tempString.slice(0, lineEndIndex));\n\t\t\ttempString = tempString.slice(lineEndIndex + 1);\n\t\t}\n\t\tlines.push(tempString);\n\n\t\treturn lines;\n\t}\n\n\tinsertTextAfterLine(text: string, body: string, line: number, filePath): string {\n\t\tconst splitContent = body.split(\"\\n\");\n\t\tconst pre = splitContent.slice(0, line + 1).join(\"\\n\");\n\t\tconst post = splitContent.slice(line + 1).join(\"\\n\");\n\n\t\treturn `${pre}\\n${text}\\n${post}`;\n\t}\n\n\tasync copyTextToSection(text, section, filePath){\n\t\t//console.log(filePath)\n\t\tconst file = await this.app.workspace.getActiveFile();\n\t\tconst fileContent = await this.app.vault.read(file);\n\t\tconst fileContentLines: string[] = this.getLinesInString(fileContent);\n\t\tconst mdHeadings = this.getMarkdownHeadings(fileContentLines);\n\t\tif (mdHeadings.length > 0) { // if there are any headings\n\t\t\tconst headingObj = mdHeadings.find(heading => heading.text.trim() === section);\n\t\t\tif (headingObj) {\n\t\t\t\tconst textWithLink = text + ` [[${filePath}|\uD83D\uDD17]]`\n\t\t\t\t//let newContent = this.insertTextAfterLine(text, fileContent, headingObj.line);\n\t\t\t\tlet newContent = this.insertTextAfterLine(textWithLink, fileContent, headingObj.line);\n\t\t\t\tawait this.app.vault.modify(file, newContent);\n\t\t\t\treturn true;\n\t\t\t} else {\n\t\t\t\tnew Notice (`Tag Buddy: ${section} not found.`);\n\t\t\t\treturn false;\n\t\t\t}\n\t\t} else {\n\t\t\tnew Notice ('Tag Buddy: There are no header sections in this note.');\n\t\t\treturn false;\n\t\t}\n\t}\n\n\tremoveTagFromString(inputText, hashtagToRemove, all:boolean=true):string {\n\t    // Use a regular expression to globally replace the hashtag with an empty string\n\t    //console.log('Tag to remove: ' + hashtagToRemove)\n\t    //const regex = new RegExp(\"\\\\s?\" + hashtagToRemove + \"\\\\b\", all?\"gi\":\"i\");\n\t    const regex = new RegExp(\"\\\\s?\" + hashtagToRemove.replace(/#/g, '\\\\#') + \"(?!\\\\w|\\\\/)\", all?\"gi\":\"i\");\n\t    return inputText.replace(regex, '').trim();\n\t}\n\n\t/*getSectionTitleWithHashes(sectionTitle) {\n\t    const activeView = this.app.workspace.getActiveViewOfType(MarkdownView);\n\t    if (!activeView) {\n\t        console.log('No active markdown view found.');\n\t        return null;\n\t    }\n\n\t    const contentEl = activeView.contentEl;\n\n\t    // Get all heading elements\n\t    // This doesn't work with super long notes. \n\t    const headings = contentEl.querySelectorAll('h1, h2, h3, h4, h5, h6');\n\t    //const headings = await contentEl.getElementsByClassName('h1, h2, h3, h4, h5, h6');\n\t    \n\t    //console.log(headings)\n\t    for (const heading of headings) {\n\t        if (heading.textContent.trim() === sectionTitle.trim()) {\n\t            // Determine the number of hashes based on the heading level\n\t            const level = parseInt(heading.tagName.substr(1), 10);  // e.g., \"H2\" -> 2\n\t            const hashes = '#'.repeat(level);\n\t            //console.log(heading);\n\t            return {md:`${hashes} ${sectionTitle}`, el:heading};\n\t        }\n\t    }\n\n\t    console.log(`Section \"${sectionTitle}\" not found.`);\n\t    return null;\n\t}*/\n\n\ttruncateStringAtWord(str, maxChars) {\n\t    if (str.length <= maxChars) return str;\n\t    let truncated = str.substr(0, maxChars);  \n\t    const lastSpace = truncated.lastIndexOf(' '); \n\t    if (lastSpace > 0) truncated = truncated.substr(0, lastSpace); // Truncate at the last full word\n\t    return truncated\n\t}\n\n\tasync readFiles(listFiles: TFile[]): Promise<[TFile, string][]> {\n\t\tlet list: [TFile, string][] = [];\n\t\tfor (let t = 0; t < listFiles.length; t += 1) {\n\t\t\tconst file = listFiles[t];\n\t\t\tlet content = await this.app.vault.cachedRead(file);\n\t\t\tlist.push([file, content]);\n\t\t}\n\t\treturn list;\n\t}\n\n\tisValidText(listTags: string[], tags: string[], include: string[], exclude: string[]): boolean {\n\t\tlet valid = true;\n\n\t\t// Check OR (tags)\n\t\tif (tags.length > 0) {\n\t\t\tvalid = valid && tags.some((value) => listTags.includes(value));\n\t\t}\n\t\t// Check AND (include)\n\t\tif (include.length > 0) {\n\t\t\tvalid = valid && include.every((value) => listTags.includes(value));\n\t\t}\n\t\t// Check NOT (exclude)\n\t\tif (valid && exclude.length > 0) {\n\t\t\tvalid = !exclude.some((value) => listTags.includes(value));\n\t\t}\n\t\treturn valid;\t\t\n\t}\n\n\tasync validateFilePath (filePath) {\n\t\tconst matchingFiles = await app.vault.getFiles().filter(file => file.name === filePath);\n\t\tif (matchingFiles.length === 1) {\n\t\t\tconst filePath = matchingFiles[0].path;\n\t\t\tconst file = await this.app.vault.getAbstractFileByPath(filePath);\n\t\t\t//console.log('Validate file: ' + embedFile.name);\n\t\t\treturn file;\n\t\t} else if (matchingFiles.length > 1) {\n\t\t\tnew Notice('Tag Buddy: Multiple files found with the same name. Can\\'t safely edit tag.');\n\t\t\treturn null;\n\t\t} else {\n\t\t\tnew Notice('Tag Buddy: No file found. Try again, or this tag might be in an unsupported embed type.');\n\t\t\treturn null;\n\t\t}\n\t}\n\n\tcontentChangedTooMuch(original, modified, tag, buffer = 5) {\n\t  const expectedChange = tag.length; // including the '#' symbol\n\t  const threshold = expectedChange + buffer; // allow for some minor unintended modifications\n\t  const actualChange = Math.abs(original.length - modified.length);\n\n\t  return actualChange > threshold;\n\t}\n\n\tasync loadSettings() {\n\t\tthis.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());\n\t}\n\n\tasync saveSettings() {\n\t\tawait this.saveData(this.settings);\n\t}\n\n\tisTagValid (tag:string):boolean { // including the #\n\t\tconst tagPattern = /^#[\\w]+$/;\n\t\treturn tagPattern.test(tag);\n\t}\n\n\tsaveRecentTag (tag:string) {\n\n\t\tif (this.isTagValid(tag)) {\n\n\t\t\t\n\t\t\tconst recentTagsString = this.settings.recentlyAddedTags;\n\t\t\tlet recentTags:Array;\n\t\t\tif (recentTagsString == '') {\n\t\t\t\trecentTags = [];\n\t\t\t} else if (recentTagsString.indexOf(', ')) {\n\t\t\t\trecentTags = this.settings.recentlyAddedTags.split(', ');\n\t\t\t} else {\n\t\t\t\trecentTags = [this.settings.recentlyAddedTags]\n\t\t\t}\n\n\t\t\tif (recentTags.includes(tag)) {\n\t\t\t\trecentTags.splice(recentTags.indexOf(tag), 1);\n\t\t\t}\n\n\t\t\trecentTags.unshift(tag.trim());\n\t\t\trecentTags = recentTags.slice(0, 3);\n\t\t\tthis.settings.recentlyAddedTags = recentTags.join(', ');\n\t\t\tthis.saveSettings();\n\t\t}\n\t}\n\n\tgetRecentTags ():Array {\n\t\tconst recentTags = this.settings.recentlyAddedTags==''?[]:this.settings.recentlyAddedTags.split(', ');\n\t\treturn recentTags;\n\t}\n\n\t// fuck.this.function\n\t/*cleanString(input) {\n\t\tlet cleanedStr;\n\n\t\t// Check if input is a DOM element\n\t\tif (input instanceof Element) {\n\t\t\t//console.log('input is: Element');\n\t\t\tcleanedStr = input.outerHTML.trim();\n\t\t} else {\n\t\t\t//console.log('input is: String');\n\t\t\tcleanedStr = input.trim();\n\t\t}\n\n\t\t// Whitespace normalization\n\t\t//cleanedStr = cleanedStr.replace(/\\s+/g, ' ');\n\n\t\t// Remove <br> elements\n\t\t//cleanedStr = cleanedStr.replace(/<br>/g, ' ');\n\n\t\t// Remove blockquote tags but keep their content\n\t\t//cleanedStr = cleanedStr.replace(/<\\/?blockquote>/g, '');\n\n\t\t// Remove blockquote tags but keep their content\n\t\t//cleanedStr = cleanedStr.replace(/<\\/?div>/g, '');\n\n\t\t// Remove spaces between tags\n\t\t//cleanedStr = cleanedStr.replace(/>\\s+</g, '><');\n\n\t\t// Whitespace normalization\n\t\tcleanedStr = cleanedStr.replace(/\\s+/g, ' ');\n\n\t\t// HTML entity decoding\n\t\tconst textArea = document.createElement('textarea');\n\t\ttextArea.innerHTML = cleanedStr;\n\t\tcleanedStr = textArea.value.trim();\n\n\t\t// Optional: convert to lowercase\n\t\t// cleanedStr = cleanedStr.toLowerCase();\n\n\t\treturn cleanedStr;\n\t}*/\n\n\t/*async refreshView (){\n\t\t//console.log('Refresh view.');\n\t\tnew Notice ('Refresh view.');\n\t\t// if using rerender,\n\t\t//const scrollState = this.app.workspace.getActiveViewOfType(MarkdownView)?.currentMode?.getScroll();\n\t\t//await view.previewMode.rerender(true);\n\n\t\tawait app.workspace.activeLeaf.rebuildView();\n\t\t// only needed if we use rerender above. do this on a timeout\n\t\t//this.app.workspace.getActiveViewOfType(MarkdownView).previewMode.applyScroll(scrollState);\n\t}*/\n\n    injectStyles() {\n    // Check if the styles have already been injected to avoid duplication\n    //if (document.getElementById('my-plugin-styles')) return;\n\n    \tconst styles = `\n        .tagsummary-notags {\n        \tcolor: var(--link-color) !important;\n        \tfont-weight: 500 !important;\n        \tborder: 1px solid var(--link-color) !important; \n        \tborder-radius: 5px !important;\n        \tpadding: 10px 10px;\n        }\n\n        .tagsummary-button {\n\n            color: var(--text-primary) !important;\n            /*border: .5px solid var(--text-quote) !important;*/\n            border-radius: 6px !important;\n            padding: 2.5px 5px !important;\n            font-size: 65% !important;\n            transition: background-color 0.3s !important;\n            margin: 0px 3px 0px 0px !important;\n            min-width: 40px !important;\n\n\t       color: var(--link-color) !important;\n\t       border: 1px solid var(--link-color) !important; \n\t\t   background-color: var(--background-primary) !important;\n\n        }\n\n        .tagsummary-button:hover {\n            background-color: var(--link-color) !important;\n            color: var(--background-secondary) !important;\n        }\n\n        .tagsummary-item-title {\n            margin: 5px 0px\n        }\n\n        .tagsummary-buttons {\n            /*float: right;*/\n            text-align: right !important;\n        }\n\n\t\tblockquote.tag-summary-paragraph {\n\t\t  transition: height 0.3s, opacity 0.3s;\n\t\t  /*transition: height 0.3s ease, margin 0.3s ease, padding 0.3s ease, opacity 0.3s ease;*/\n\t\t  overflow: hidden;\n\t\t}\n\n\t\t.removing {\n\t\t  height: 0 !important; \n\t\t  opacity: 0;\n\t\t  margin: 0;\n\t\t  padding: 0;\n\t\t}\n\n\t    @media only screen and (max-device-width: 480px), \n\t       only screen and (max-width: 480px) and (orientation: landscape),\n\t       only screen and (max-device-width: 1024px), \n\t       only screen and (min-width: 481px) and (max-width: 1024px) and (orientation: landscape) {\n\t\t   .tagsummary-button {\n\t\t       display: inline-block !important;\n\t\t       font-size: 12px !important;\n\t\t       padding: 5px 5px;\n\t\t       box-shadow: none;  /* remove shadows if they look off */\n\t\t       border-radius: 4px;\n\t\t       color: var(--link-color) !important;\n\t\t       border: 1px solid var(--link-color); \n\t\t       width: auto !important;            /* auto adjusts width based on content */\n    \t\t   /*max-width: 60px !important;  */  \n    \t\t   max-height: 30px !important;\n    \t\t   min-width: 40px !important;\n    \t\t   white-space: nowrap;\n    \t\t   /*text-align: left !important;*/\n    \t\t   overflow: hidden;\n    \t\t   background-color: var(--background-primary) !important;\n\t\t   }\n\t\t}\n\n\t\t.addtag-menu {\n\t\t\tposition: absolute !important;\n\t\t    background-color: var(--background-primary) !important;\n\t\t    /*color: white !important;*/\n\t\t    border: 2px solid var(--divider-color) !important;\n\t\t    z-index: 10000 !important;\n\t\t    overflow-y: auto !important;\n\t\t    /*max-height: 150px !important;*/\n\t\t    width: 150px !important;\n\t\t    box-shadow: 5px 5px 20px rgba(0, 0, 0, 0.5) !important;\n\t        border-radius: 8px !important;  \n\t        font-family: Arial, sans-serif;  \n\t        font-size: 12px !important;\n\t        overflow: hidden !important;  // Hide overflow\n\t\t\tpadding-right: 10px !important;  // Adjust padding to make space for scrollbar\n\t\t\tbox-sizing: border-box !important; \n\t\t\t\n    \t\tborder-radius: 10px !important;\n    \t\t\n\t\t}\n\n\t\t.tag-list {\n\t\t\toverflow-y: auto !important;\n\t\t    overflow-x: hidden !important; \n\t\t    /*padding-right: 8px !important;  // Adjust padding to give space for scrollbar\n\t\t    /*margin-right: -8px !important;  // Adjust margin to move scrollbar into the padding*/\n\t\t    box-sizing: border-box !important; \n\t\t}\n\n\t\t.tag-item {\n\t\t\tpadding: 5px 10px 5px 10px !important;  \n            cursor: pointer !important;\n           /* border-bottom: 1px solid var(--divider-color) !important;  // Separator line*/\n            font-size: 14px !important;\n            /*width: 130px !important;*/\n            width: 100% !important;\n            /*height: 20px !important;*/\n            text-overflow: ellipsis !important; \n\t\t\twhite-space: nowrap !important;  \n\t\t\tbox-sizing: border-box !important; \n\n\t\t\t\n\t\t\ttransition: background-color 0.2s ease !important; \n\t\t\tborder-radius: 5px !important; \n\t\t}\n\n\t\t.tag-item:hover {\n\t        background-color: var(--background-modifier-hover) !important; // Added ,1 for opacity\n\t        /*color: white !important;*/\n\t    }\n\t\t.tag-item.active {\n\t        background-color: var(--background-modifier-hover) !important;\n\t        /*background-color: var(--interactive-accent) !important;*/\n\t        /*color: white !important;*/\n\t    }\n\n\t\t#addtag-menu .disable-hover .tag-item:hover {\n\t\t    background-color: inherit !important;\n\t\t    color: inherit !important;\n\t\t}\n\n\t    .tag-search {\n\t     \twidth: 100% !important;\n\t        padding: 2.5px 5px !important;\n\t        border: none !important;\n\t        font-family: Arial, sans-serif;\n\t        font-size: 14px !important;\n\t    }\n\n        .tag-search:focus {\n        \toutline: none !important;\n        \tborder: none !important;\n        \tborder-bottom: 0px !important;\n        \tbox-shadow: none !important;\n        \toutline-style: none !important;\n    \t\toutline-width: 0px !important;\n\n\n        } \n\n    `;\n\n\t    const styleSheet = createEl(\"style\");\n\t    styleSheet.type = \"text/css\";\n\t    styleSheet.innerText = styles;\n\t    styleSheet.id = 'tag-buddy-styles'; // ID to prevent injecting the styles multiple times\n\t    document.head.appendChild(styleSheet);\n\t}\n\n\tasync getEmbedFile (el):TFile {\n\t\tlet filePath = el.getAttribute('src');\n\t\tconst linkArray = filePath.split('#');\n\t\tfilePath = linkArray[0].trim() + '.md';\n\t\tconst file = await this.validateFilePath(filePath);\n\t\t//const fileContent = await this.app.vault.read(file);\n\t\treturn file; //Content;\n\t}\n\n\tasync getSummaryFile (el):TFile {\n\t\tconst filePath = el.getAttribute('file-source'); \n\t\tconst file = await this.app.vault.getAbstractFileByPath(filePath);\n\t\t//const fileContent = await this.app.vault.read(file);\n\t\treturn file;\n\t}\n\n\tshowTagSelector(x: number, y: number) {\n\t\t//console.log('show tag inspector')\n\t\t// Adjustments for the scrollbar and dynamic height\n\t\tconst maxTagContainerHeight = 170; // This is a chosen max height, adjust as desired\n\t\tconst tagItemHeight = 30; // Approximate height of one tag item, adjust based on your styles\n\t\t// 30 works perfect based on other padding and margin. 20 breaks it when there's one left.\n\n\t    // Remove any existing context menu\n    \tconst existingMenu = document.getElementById('addtag-menu');\n    \tif (existingMenu) existingMenu.remove();\n\n\t    const menuEl = createEl('div');\n\t    menuEl.setAttribute('id', 'addtag-menu');\n\t    menuEl.classList.add('addtag-menu');\n\t    menuEl.style.left = `${x}px`;\n\t\tmenuEl.style.top = `${y}px`;\n\t\t//menuEl.style.maxHeight = `${maxTagContainerHeight}px;`;\n\n\t    // Create and style the search input field\n\t    const searchEl = createEl('input');\n\t    searchEl.setAttribute('type', 'text');\n\t    searchEl.setAttribute('id', 'tag-search');\n\t    searchEl.classList.add('tag-search');\n\t    searchEl.setAttribute('placeholder', 'Search tags...');\n\t    \n\t    menuEl.appendChild(searchEl);\n\t    // Container for the tags\n\t    const tagContainer = createEl('div');\n\t    //tagContainer.setAttribute('id', 'tag-list');\n\t    tagContainer.classList.add('tag-list');\n\t    //tagContainer.style.maxHeight = `${maxTagContainerHeight}px;`;\n\t    //tagContainer.style.setProperty('height', `${maxTagContainerHeight}px`, 'important');\n\t    tagContainer.style.setProperty('max-height', `${maxTagContainerHeight}px`, 'important');\n\n\t    menuEl.appendChild(tagContainer);\n\n\t\tconst renderTags = (searchQuery: string) => {\n\t    \ttagContainer.innerHTML = '';  // Clear existing tags\n\t    \t//const filteredTags = this.fetchAllTags().filter(tag => tag.includes(searchQuery));\n\t    \tconst filteredTags = this.getTagsFromApp().filter(tag => tag.toLowerCase().includes(searchQuery.toLowerCase()));\n\t    \t// Set the dynamic height based on the number of results\n\t    \t// +10 needed fixes an unsquashable bug when only one item remains in the search\n\t    \tconst dynamicHeight = Math.min(filteredTags.length * tagItemHeight, maxTagContainerHeight)//+10;\n\t    \t\n\t    \n\t\t    filteredTags.forEach((tag, index) => {\n\t\t        const itemEl = createEl('div');\n\t\t        itemEl.innerText = `${tag}`;\n\t\t        itemEl.classList.add('tag-item');\n\t\t        itemEl.title = `#${tag}`;\n\t            if (index === 0) {\n\t                itemEl.classList.add('active');  // Add active class to the first tag\n\t            }\n\t            itemEl.style.setProperty('max-height', `${dynamicHeight}px`, 'important');\n\n\t\t        this.registerDomEvent(itemEl, 'click', (e) => {\n\t\t        //itemEl.addEventListener('click', () => {\n\t\t\t\t    //console.log(`-----> Selected tag: #${tag}`);\n\t\t\t\t    // Add your logic here to insert the tag into the note\n\t\t        \tthis.addTag('#'+tag, x, y)\n\t\t\t\t    // Close the menu after selection\n\t\t\t\t    menuEl.remove();\n\t\t\t\t}, true);\n\n\t        \ttagContainer.appendChild(itemEl);\n    \t\t});\n\n\n\t\t    if (filteredTags.length * tagItemHeight > maxTagContainerHeight) {\n\t\t        tagContainer.style.overflowY = 'auto !important';\n\t\t    } else {\n\t\t        tagContainer.style.overflowY = 'hidden !important';\n\t\t    }\n\t\t};\n\n\t\t// Handle Enter key press\n\t\tthis.registerDomEvent(searchEl, 'keyup', (e: KeyboardEvent) => {\n\t\t//searchEl.addEventListener('keydown', (e: KeyboardEvent) => {\n\t\t\tconst searchQuery = (e.target as HTMLInputElement).value.trim();\n\t\t\tconst pattern = /^[^\\s\\p{P}]+$/u; \n\t\t\t//const isValid = pattern.test(\"example\"); \n\n\n\t\t    if (e.key === 'Enter') {\n\t\t        const activeTag = tagContainer.querySelector('.active');\n\t\t        if (activeTag) {\n\t\t            //activeTag.click();  // Simulate a click on the active tag\n\t\t            this.addTag('#'+activeTag.innerText, x, y);\n\t\t        } else if (pattern.test(searchQuery)) {\n\t\t        \tthis.addTag('#'+searchQuery, x, y);\n\t\t        }\n\t\t        menuEl.remove();\n\t\t    }\n\t\t});\n\n\t    // Initial render\n\t    renderTags('');\n\n\t    // Event listener for search input\n\t    searchEl.addEventListener('input', (e) => {\n\t        renderTags((e.target as HTMLInputElement).value);\n\t    });\n\n\t\t// const debouncedProcessTags = this.debounce(this.processTags.bind(this), 500);\n\n\t    // Add the menu to the document\n\t    document.body.appendChild(menuEl);\n\n\t    // Auto-focus on the search input\n    \tsearchEl.focus();\n\n\t\tconst closeMenu = (e: MouseEvent | KeyboardEvent) => {\n\t\t    if (e instanceof MouseEvent && (e.button === 0 || e.button === 2)) {\n\t\t        if (!menuEl.contains(e.target as Node)) {  // Check if the click was outside the menu\n\t\t            menuEl.remove();\n\t\t            //console.log('Enter 1')\n\n\t\t            document.body.removeEventListener('click', closeMenu);\n\t\t            document.body.removeEventListener('contextmenu', closeMenu);\n\t\t            document.body.removeEventListener('keyup', closeMenu);\n\t\t        }\n\t\t    } else if (e instanceof KeyboardEvent && e.key === 'Escape') {\n\t\t        menuEl.remove();\n\t\t        document.body.removeEventListener('click', closeMenu);\n\t\t        document.body.removeEventListener('contextmenu', closeMenu);\n\t\t        document.body.removeEventListener('keyup', closeMenu);\n\t\t    }\n\t\t};\n\n\t\tsetTimeout(() => {\n\t\t    //document.body.addEventListener('click', closeMenu);\n\t\t    //document.body.addEventListener('contextmenu', closeMenu);  // Listen for right clicks too\n\t\t    //document.body.addEventListener('keydown', closeMenu);\n\t\t    this.registerDomEvent(document.body, 'click', closeMenu);\n            this.registerDomEvent(document.body, 'contextmenu', closeMenu);\n            this.registerDomEvent(document.body, 'keyup', closeMenu);\n\t\t}, 0);\n\n\t\t//tagContainer.addEventListener('mousemove', () => {\n\t\tthis.registerDomEvent(tagContainer, 'mousemove', () => {\n\t\t    // Reactivate the hover effect\n\t\t    tagContainer.classList.remove('disable-hover');\n\t\t    \n\t\t    // Find any tag with the 'active' class and remove that class\n\t\t    const activeTag = tagContainer.querySelector('.tag-item.active');\n\t\t    if (activeTag) {\n\t\t        activeTag.classList.remove('active');\n\t\t    }\n\t\t});\n\n\t\t// Handle Enter key press\n\t\t//searchEl.addEventListener('blur', () => {\n\t\tthis.registerDomEvent(searchEl, 'blur', () => {\n\t\t    tagContainer.classList.remove('disable-hover');\n\t\t});\n\t    //searchEl.addEventListener('keydown', (e: KeyboardEvent) => {\n\t\tthis.registerDomEvent(searchEl, 'keydown', (e: KeyboardEvent) => {\n\t\t    const activeTag = tagContainer.querySelector('.active');\n\t\t    let nextActiveTag;\n\t\t    if (['ArrowUp', 'ArrowDown'].includes(e.key) || e.key.length === 1) { // Check for arrow keys or any single character key press\n\t\t        tagContainer.classList.add('disable-hover');\n\t\t    }\n\t\t    if (e.key === 'ArrowDown') {\n\t\t        if (activeTag && activeTag.nextElementSibling) {\n\t\t            nextActiveTag = activeTag.nextElementSibling;\n\t\t        } else {\n\t\t            nextActiveTag = tagContainer.firstChild; // loop back to the first item\n\t\t        }\n\t\t    } else if (e.key === 'ArrowUp') {\n\t\t        if (activeTag && activeTag.previousElementSibling) {\n\t\t            nextActiveTag = activeTag.previousElementSibling;\n\t\t        } else {\n\t\t            nextActiveTag = tagContainer.lastChild; // loop back to the last item\n\t\t        }\n\t\t    } else if (e.key === 'Enter') {\n\t\t        //if (activeTag) {\n\t\t        //\tconsole.log('Enter 2') // this never happens.\n\t\t        //    activeTag.click();\n\t\t        //    return;\n\t\t       // }\n\t\t    }\n\n\t\t    if (nextActiveTag) {\n\t\t        if (activeTag) {\n\t\t            activeTag.classList.remove('active');\n\t\t        }\n\t\t        nextActiveTag.classList.add('active');\n\t\t        // Ensure the newly active tag is visible\n\t\t        nextActiveTag.scrollIntoView({ block: 'nearest' });\n\t\t        searchEl.value = nextActiveTag.innerText;\n\t\t    }\n\t\t});\n\t}\n\n\tasync addTag (tag:string, x:number, y:number) {\n\n\t\tif (this.settings.debugMode) { console.log('Tag Buddy add'); console.log(x, y, tag); }\n\n\t\tlet fileContent:string;\n\t\tlet file:TFile;\n\t\tconst clickedTextObj = this.getClickedTextObjFromDoc (x, y);\n\t\tconst clickedText:string = clickedTextObj?.text;\n\t\tconst clickedTextIndex:number = clickedTextObj?.index; // this is the index in document, for narrowing down to the word clicked.\n\t\tconst clickedTextEl:HTMLElement = clickedTextObj?.el;\n\t\tlet contentSourceType:string = null\n\t\tlet summaryEl:HTMLElement;\n\t\tlet embedEl:HTMLElement;\n\n\t\tif (clickedTextObj) {\n\n\t\t\tsummaryEl = clickedTextEl.closest('.tag-summary-paragraph');\n\t\t\tembedEl = clickedTextEl.closest('.markdown-embed');\n\n\t\t\tif (summaryEl) {\n\t\t\t\t\n\t\t\t\tfile = await this.getSummaryFile(summaryEl);\n\t\t\t\tfileContent = await this.app.vault.read(file);\n\t\t\t\tcontentSourceType = 'plugin-summary';\n\t\t\t\t//console.log('In a summary')\n\n\t\t\t\t//console.log(fileContent)\n\t\t\t\t\n\t\t\t} else if (embedEl) {\n\t\t\t\t//console.log('In an embed');\n\t\t\t\tfile = await this.getEmbedFile(embedEl);\n\t\t\t\tfileContent = await this.app.vault.read(file);\n\t\t\t\tcontentSourceType = 'native-embed';\n\t\t\t\t//console.log(fileContent)\n\n\t\t\t\t// !!!!!! we could be in some other kind of embed/view/plugin. Need to be sure about this.\n\t\t\t} else { \n\t\t\t\t//console.log('In a active file')\n\t\t\t\tfile = await this.app.workspace.getActiveFile();\n\t\t\t\tfileContent = await this.app.vault.read(file);\n\t\t\t\tcontentSourceType = 'active';\n\t\t\t} \n\n\t\t} else {\n\t\t\tnew Notice ('\u26A0\uFE0F Can\\'t find text position or area too busy.\\nTry a another text area.');\n\t\t    return;\n\t\t}\n\n\n\t\tif (clickedText) {\n\t\t\t//console.log (clickedText);\n\t\t} else {\n\t\t\tnew Notice ('\u26A0\uFE0F Can\\'t add tag.\\nTry a different text area.')\n\t\t\treturn;\n\t\t}\n\n\t\tconst escapedClickedText = this.escapeRegExp(clickedText);\n\t\tconst regex = new RegExp(escapedClickedText, \"g\");  // The \"g\" flag means \"global\", so it will find all occurrences\n\t\tconst matches = fileContent.match(regex);\n\n\t\tif (matches && matches.length > 1) {\n\t\t    //console.log(`Found ${matches.length} occurrences of \"${pattern}\" in \"${subject}\".`);\n\t\t    new Notice ('\u26A0\uFE0F Can\\'t add tag: Clicked text repeated in note. Try a another text block.');\n\t\t    return;\n\t\t} else if ((matches && matches.length === 0) || !matches) {\n\t\t\tnew Notice ('\u26A0\uFE0F Can\\'t find text position or area too busy.\\nTry a another text area.');\n\t\t    return;\n\t\t} \n\n\t\tif (!this.settings.lockRecentTags) this.saveRecentTag (tag); \n\t\t\n\t\tconst startIndex = regex.exec(fileContent).index; // this is the index in the md source\n\t\tconst endIndex = startIndex + clickedText.length-1;\n\n\t\tconst clickedWordObj = this.getWordObjFromString (clickedText, clickedTextIndex);\n\t\tconst clickedWord = clickedWordObj.text;\n\t\tconst clickedWordIndex = clickedWordObj.index;\n\t\t\n\n//console.log(JSON.stringify(tag))\n\t\t\t\n//console.log ('before tag ends with space? ' + before.startsWith(' '))\n//console.log ('before tag ends with linebreak? ' + before.startsWith('\\n'))\n\n\n\t\tconst newContent = this.insertTextInString(tag, fileContent, startIndex+clickedWordIndex)\n\t\t\n\n\t\t// modify file\n\t\t//console.log(newContent)\n\t\tawait this.app.vault.modify(file, newContent);\n\n\t\tif (contentSourceType == 'plugin-summary') {\n\t\t\tconst summaryContainer = summaryEl.closest('.tag-summary-block')\n\t\t\tthis.updateSummary(summaryContainer); \n\t\t}\n\n\t\tsetTimeout(async () => { this.processTags(); }, 200);\n\t}\n\n\treplaceTextInString (replaceText, sourceText, newText, all:boolean=false):string {\n\n\t\tconst regex = new RegExp(this.escapeRegExp(replaceText), all ? \"gi\" : \"i\");\n    \treturn sourceText.replace(regex, newText).trim();\n\t}\n\n\t// I removed .trim() from the before and after to fix the add bug.\n\tinsertTextInString (newText, sourceText, charPos):string { // pass 0 for the start or sourceText.length-1 for the end\n\n\t\t// LATER: Proper white space or line break checking of the area we're adding\n\t\t//return (sourceText.substring(0, charPos).trim() + ' ' + newText + ' ' + sourceText.substring(charPos)).trim();\n\t\treturn (sourceText.substring(0, charPos) + ' ' + newText + ' ' + sourceText.substring(charPos));\n\t}\n\n\tremoveTextFromString (removeText, sourceText, all:boolean=false):string {\n\n\t\tconst regex = new RegExp(this.escapeRegExp(removeText), all ? \"gi\" : \"i\");\n    \treturn sourceText.replace(regex, '').trim();\n\t}\n\n\tgetWordObjFromString(sourceText, offset):Object {\n\t\tlet wordRegex = /[^\\s]+(?=[.,:!?]?(\\s|$))/g;\n\t\tlet match;\n\t\tlet index;\n\t\tlet word = null;\n        while ((match = wordRegex.exec(sourceText)) !== null) {\n            if (match.index <= offset && offset <= match.index + match[0].length) {\n                // This is our word\n                //if (!/^[^\\p{L}\\p{N}]/u.test(match[0]) &&        // Not starting with any non-alphanumeric\n                //    !/[^\\p{L}\\p{N}\\s.,:!?]/u.test(match[0]) &&\t// Not containing other than allowed chars\n                //    !/[.,:!?](?=[^\\s$])/u.test(match[0])) {     // If ends with punctuation, following character must be whitespace or end of string\n                    word = match[0];\n                    index = match.index;\n                    break;\n            }\n           // }\n        }\n        return {text: word, index: index};\n\t}\n\n\tgetClickedTextObjFromDoc(x, y, minNodeLength:string=10):string {\n\t\t//const minNodeLength:number = 10;\n\n\t    // Get the word under the click position\n\t    let range, nodeText, offset;\n\n\t    // This method is better supported and gives us a range object\n\t    if (document.caretRangeFromPoint) {\n\t        range = document.caretRangeFromPoint(x, y);\n\t        \n\t        //const containerEl = range.startContainer.parentNode as HTMLElement;\n\t        //console.log(containerEl.closest('.tag-summary-block'))\n\t        \n\t        //console.log(range.startContainer.parentNode.parentNode)\n\t        \n\n\t        if (range.startContainer.nodeType === Node.TEXT_NODE) {\n        \t\tnodeText = range.startContainer.nodeValue.trim();\n    \t\t} else {\n    \t\t\t//console.log ('no text')\n    \t\t\treturn null;\n    \t\t}\n\t        offset = range.startOffset;\n\t    }\n\n\t    if (nodeText.length < minNodeLength) {\n\t    \t//console.log ('text too short')\n\t    \treturn null;\n\t\t}\n\n\t    return {text: nodeText, index: offset, el: range.startContainer.parentNode};\n\t}\n\n\t/*async getClickedWord(e) {\n\t\t//Get the click position\n\t    let x = e.clientX, y = e.clientY;\n\n\t    // Get the word under the click position\n\t    let range, textNode, offset;\n\n\t    // This method is better supported and gives us a range object\n\t    if (document.caretRangeFromPoint) {\n\t        range = document.caretRangeFromPoint(x, y);\n\t        textNode = range.startContainer;\n\t        offset = range.startOffset;\n\t    }\n\t    //console.log(textNode)\n\n\t    // LATER, double check different notes types and around the interface\n\n\t    // Check if we have a valid text node\n\t    if (textNode && textNode.nodeType === Node.TEXT_NODE) {\n\t        // Get the whole text of the clicked node\n\t        let fullText = textNode.textContent;\n\n\t        // LATER: if the word end in valid punctuation, add a space between word and punctuation it when adding the hash.\n\t        // LATER, have predefined tags we can insert with different key modifiers on click\n\t        // like, #todo or #inbox #later\n\n\t        let wordRegex = /[^\\s]+(?=[.,:!?]?(\\s|$))/g;\n\t\t\tlet match;\n\t\t\tlet clickedWord = null;\n\t        while ((match = wordRegex.exec(fullText)) !== null) {\n\t            if (match.index <= offset && offset <= match.index + match[0].length) {\n\t                // This is our word\n\t                if (!/^[^\\p{L}\\p{N}]/u.test(match[0]) &&        // Not starting with any non-alphanumeric\n\t                    !/[^\\p{L}\\p{N}\\s.,:!?]/u.test(match[0]) &&\t// Not containing other than allowed chars\n\t                    !/[.,:!?](?=[^\\s$])/u.test(match[0])) {     // If ends with punctuation, following character must be whitespace or end of string\n\t                    clickedWord = match[0];\n\t                    break;\n\t                }\n\t            }\n\t        }\n\n\n\t\t\tlet activeView = await this.app.workspace.getActiveViewOfType(MarkdownView);\n\n\t\t\t\n\t\t    let editor = activeView.sourceMode.cmEditor;  // Get the CodeMirror instance\n\t\t    let fullNote = editor.getValue(); \n\n\t\t\tconst globalStartPosition = fullNote.indexOf(textNode.textContent);\n\n\t\t\tif (globalStartPosition !== -1) {\n\t\t\t    // Assuming the click was right at the end of the word\n\t\t\t    let wordEndPosition = globalStartPosition + offset;\n\n\t\t\t    // Traverse backward until a space or start\n\t\t\t    while (wordEndPosition > 0 && fullNote[wordEndPosition] !== ' ' && fullNote[wordEndPosition] !== '\\n') {\n\t\t\t        wordEndPosition--;\n\t\t\t    }\n\n\t\t\t    wordEndPosition++;\n\n\t\t\t    // Insert hash at wordEndPosition\n\t\t\t    const updatedNote = [fullNote.slice(0, wordEndPosition), '#', fullNote.slice(wordEndPosition)].join('');\n\t\t\t    console.log(updatedNote);\n\t\t\t}\n\n\n\t\t}\n\n\t\t// LATER, to make this work in embeds and summaries\n\t\t// and avoid adding when in the summary empty block. or other code blocks. maybe this check is earlier.\n\t}*/\n\n\tescapeRegExp(string):string {\n    \treturn string.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&'); // $& means the whole matched string\n\t}\n\n\tgetTagsFromApp(): string[] {\n\t    const tagsObject = this.app.metadataCache.getTags();\n\n\t    // Convert tagsObject to an array of [tag, count] tuples\n\t    const tagsArray = Object.entries(tagsObject);\n\n\t    // Sort by use count\n\t    tagsArray.sort((a, b) => b[1] - a[1]);\n\n\t    const recentTags = this.getRecentTags();\n\t   // console.log('recent tag length: ' + recentTags.length)\n\n\t    if (recentTags.length>0) {\n\t    \t//console.log(recentTags)\n\t    \t// convert them to [tag, count] tuples for consistency\n\t   \t\tconst recentTagsAsTuples = recentTags.map(tag => [tag, 0]);\n\t    \t// Concatenate the two arrays\n\t    \tconst recentAndAllTags = recentTagsAsTuples.concat(tagsArray);\n\t    \t// Extract tag names after removing the #\n\t    \treturn recentAndAllTags.map(([tag, _]) => tag.replace(/^#/, \"\"));\n       \t} else {\n       \t\treturn tagsArray.map(([tag, _]) => tag.replace(/^#/, \"\"));\n       \t}\n\t}\n\n\tgetTagElement(paragraphEl, tagText) {\n\t    //console.log('Get tag element')\n\t    const els = paragraphEl.querySelectorAll('.tag'); \n\t    //Array.from(els).map(el => console.log(el.innerText));\n\t    let tagElText = '';\n\t    let tagElHasSub:boolean;\n\t    for (let el of els) {\n\t    \ttagElText = el.innerText.trim();\n\t    \t//console.log(tagElText + ' == ' + tagText)\n\t    \tif (tagElText === tagText) {\n\t    \t\t//console.log(el.innerText)\n\t    \t\t//console.log(el)\n\t    \t\treturn el\n\t    \t}\n\t    \t//tagElText = el.innerText.trim();\n\t    \t//tagElHasSub = tagElText.includes('/')\n\t    \t//console.log(tagElText + ' has sub? ' + tagElHasSub)\n\t    }\t\n\t    /*for (let el of els) {\n\t    \tconsole.log(el.innerText)\n\t    \ttagElText = el.innerText.trim();\n\t    \ttagElHasSub = tagElText.includes('/')\n\t    \t//console.log(tagElText + ' has sub? ' + tagElHasSub)\n\t        if (tagElHasSub) {\n\t        \t//console.log(el);\n\t        \tcontinue;\n\t        } else if (tagElText === tagText && (!tagElHasSub || (tagElHasSub && (tagElText === tagText)))) {\n\t            return el;\n\t        }\n\t    }*/\n\n\t    console.warn(`Element with text \"${tagText}\" not found`);\n\t    return null;\n\t}\n\n\tctrlCmdKey (event) {\n\t\tconst isMac = (navigator.platform.toUpperCase().indexOf('MAC') >= 0);\n\n\t\tif (isMac) return event.metaKey;\n\t\telse return event.ctrlKey;\n\t}\n\n\tdebounce(func, wait) {\n    \tlet timeout;\n    \treturn function(...args) {\n        \tconst context = this;\n        \tclearTimeout(timeout);\n        \ttimeout = setTimeout(() => {\n            \tfunc.apply(context, args);\n        \t}, wait);\n    \t};\n\t}\n}\n\nclass TempComponent extends Component {\n\tonload() {}\n\tonunload() {}\n}\n\nclass DoubleTapHandler {\n  constructor(plugin, element, callback) {\n    this.plugin = plugin; // Store the plugin instance\n    this.element = element;\n    this.callback = callback;\n    this.lastTap = 0;\n    //new Notice('double tap created')\n    this.plugin.registerDomEvent(this.element, 'touchend', this.handleTouchEnd.bind(this), true);\n  }\n\n  handleTouchEnd(event) {\n    const currentTime = new Date().getTime();\n    const tapLength = currentTime - this.lastTap;\n    clearTimeout(this.timeout);\n    \n    if (tapLength < 500 && tapLength > 0) {\n      //event.preventDefault();\n      //event.stopPropagation();\n      //new Notice('double tap fired');\n      this.callback(event);\n    } else {\n      this.timeout = setTimeout(() => {\n        clearTimeout(this.timeout);\n      }, 500);\n    }\n    this.lastTap = currentTime;\n  }\n}\n\nclass PressAndHoldHandler {\n  constructor(plugin, element, callback, duration = 600) {\n    this.plugin = plugin;\n    this.element = element;\n    this.callback = callback;\n    this.duration = duration; // duration in milliseconds to consider as \"hold\"\n    this.timeout = null;\n\n    //new Notice ('pressAndHold created.')\n\n    this.plugin.registerDomEvent(this.element, 'touchstart', this.handleTouchStart.bind(this), true);\n    this.plugin.registerDomEvent(this.element, 'touchend', this.handleTouchEnd.bind(this), true);\n  }\n\n  handleTouchStart(event) {\n    //event.preventDefault();\n    //event.stopPropagation();\n    this.timeout = setTimeout(() => {\n    \t//new Notice ('pressAndHold event fired.')\n      this.callback(event);\n      this.timeout = null;\n    }, this.duration);\n  }\n\n  handleTouchEnd(event) {\n    if (this.timeout) {\n      clearTimeout(this.timeout);\n      this.timeout = null;\n    }\n  }\n}\n", "\nimport TagBuddy from \"main\";\nimport { App, PluginSettingTab, Setting } from \"obsidian\";\n\nexport class TBSettingsTab extends PluginSettingTab {\n    plugin: TagBuddy;\n\n    constructor(app: App, plugin: TagBuddy) {\n        super(app, plugin);\n        this.plugin = plugin;\n    }\n    display(): void {\n        let { containerEl } = this;\n        containerEl.empty();\n\n        containerEl.createEl(\"h1\", { text: \"Tag Buddy\" });\n\n        new Setting(containerEl)\n        .setName(\"Override native tag search on click\")\n        .setDesc(\"Toggle OFF to use CTRL/CMD+CLICK to remove tag.\")\n        .addToggle((toggle) =>\n            toggle\n            .setValue(this.plugin.settings.removeOnClick)\n            .onChange(async (value) => {\n                this.plugin.settings.removeOnClick = value;\n                await this.plugin.saveSettings();\n            })\n        );\n\n        new Setting(containerEl)\n        .setName(\"Convert to tag text (removes #)\")\n        .setDesc(\"Toggle OFF to use OPT/ALT+CLICK to perform native tag search.\")\n        .addToggle((toggle) =>\n            toggle\n            .setValue(this.plugin.settings.optToConvert)\n            .onChange(async (value) => {\n                this.plugin.settings.optToConvert = value;\n                await this.plugin.saveSettings();\n            })\n        );\n\n        new Setting(containerEl)\n        .setName(\"Remove nested tags first\")\n        .setDesc(\"Toggle OFF to use SHIFT+CLICK to remove nested tags first.\")\n        .addToggle((toggle) =>\n            toggle\n            .setValue(this.plugin.settings.removeChildTagsFirst)\n            .onChange(async (value) => {\n                this.plugin.settings.removeChildTagsFirst = value;\n                await this.plugin.saveSettings();\n            })\n        );\n\n        new Setting(containerEl)\n        .setName(\"Mobile tag search\")\n        .setDesc(\"Toggle ON to restore mobile native tag search on tap. Tag removal will then use LONG PRESS.\")\n        .addToggle((toggle) =>\n            toggle\n            .setValue(this.plugin.settings.mobileTagSearch)\n            .onChange(async (value) => {\n                this.plugin.settings.mobileTagSearch = value;\n                await this.plugin.saveSettings();\n            })\n        );\n\n        new Setting(containerEl)\n        .setName(\"Show mobile notices\")\n        .setDesc(\"Toggle OFF to hide notices when editing or removing a tag.\")\n        .addToggle((toggle) =>\n            toggle\n            .setValue(this.plugin.settings.mobileNotices)\n            .onChange(async (value) => {\n                this.plugin.settings.mobileNotices = value;\n                await this.plugin.saveSettings();\n            })\n        );\n\n        new Setting(containerEl)\n        .setName(\"BETA: Show tag summary paragraph buttons\")\n        .setDesc(\"Show buttons below each tagged paragraph that let you copy, remove, and move the paragraph.\")\n        .addToggle((toggle) =>\n            toggle\n            .setValue(this.plugin.settings.tagSummaryBlockButtons)\n            .onChange(async (value) => {\n                this.plugin.settings.tagSummaryBlockButtons = value;\n                await this.plugin.saveSettings();\n            })\n        );\n\n        new Setting(containerEl)\n        .setName(\"BETA: Show tag summary buttons\")\n        .setDesc(\"Show buttons below each summary that let you copy or make a note from the summary.\")\n        .addToggle((toggle) =>\n            toggle\n            .setValue(this.plugin.settings.showSummaryButtons)\n            .onChange(async (value) => {\n                this.plugin.settings.showSummaryButtons = value;\n                await this.plugin.saveSettings();\n            })\n        );\n\n        new Setting(containerEl)\n        .setName(\"Copy to section prefix\")\n        .setDesc(\"When moving a tagged paragraph from tag summaries below note header sections use this prefix:\\nExample: '- ', '> ', '- [ ]'\")\n        .addText((text) => {\n            text\n            .setPlaceholder(this.plugin.settings.taggedParagraphCopyPrefix)\n            .setValue(this.plugin.settings.taggedParagraphCopyPrefix)\n            .onChange(async (value) => {\n                this.plugin.settings.taggedParagraphCopyPrefix = value;\n                await this.plugin.saveSettings();\n            });\n        });\n\n        function isValidTag(tag) {\n            const tagPattern = /^#[\\w]+$/;\n            return tagPattern.test(tag);\n        }\n\n        function filterAndJoinTags(tagsString) {\n            const tagsArray = tagsString.split(\", \");\n            const validTags = tagsArray.filter(isValidTag);\n            return validTags.join(\", \");\n        }\n\n        // Adding will always limit to 3. But if they edit it here, it can be any length.\n        new Setting(containerEl)\n        .setName(\"Recent tags\")\n        .setDesc(\"The most recent tags added via Tag Buddy are stored here. These will show up first in the list when adding.\")\n        .addText((text) => {\n            text\n            .setPlaceholder(this.plugin.settings.recentlyAddedTags)\n            .setValue(this.plugin.settings.recentlyAddedTags)\n            .onChange(async (value) => {\n                this.plugin.settings.recentlyAddedTags = filterAndJoinTags(value); //value;\n                await this.plugin.saveSettings();\n            });\n        });\n\n        new Setting(containerEl)\n        .setName(\"Lock recent tags\")\n        .setDesc(\"Toggle ON to lock the recent tags list. Recent tags will not be updated. Instead, the tags above will act like a favorites list.\")\n        .addToggle((toggle) =>\n            toggle\n            .setValue(this.plugin.settings.lockRecentTags)\n            .onChange(async (value) => {\n                this.plugin.settings.lockRecentTags = value;\n                await this.plugin.saveSettings();\n            })\n        );\n\n        containerEl.createEl('hr');\n        containerEl.createEl(\"h1\", { text: \"Support a buddy\" });\n        const donateButton = containerEl.createEl('a');\n        donateButton.setAttribute('href', 'https://www.buymeacoffee.com/moremeyou');\n        donateButton.innerHTML = `<img src=\"https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png\" alt=\"Buy Me A Coffee\" style=\"height: 40px !important;width: 150px !important;\" ></a>`;\n\n        containerEl.createEl('br');\n        containerEl.createEl('br');\n        containerEl.createEl('br');\n\n        new Setting(containerEl)\n        .setName(\"Debug mode\")\n        .setDesc(\"Output to console.\")\n        .addToggle((toggle) =>\n            toggle\n            .setValue(this.plugin.settings.debugMode)\n            .onChange(async (value) => {\n                this.plugin.settings.debugMode = value;\n                await this.plugin.saveSettings();\n            })\n        );\n    }\n}\n\n"],
  "mappings": "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",
  "names": ["app", "import_obsidian", "error", "count", "e", "notice", "filePath"]
}
 diff --git a/src/package.json b/src/package.json index a0b202f..cd9bee4 100644 --- a/src/package.json +++ b/src/package.json @@ -1,6 +1,6 @@ { "name": "TagBuddy", - "version": "0.3.0", + "version": "0.7.1", "description": "Add, edit and remove tags and copy, move or edit tagged blocks all without leaving reading-mode.", "main": "main.js", "scripts": { diff --git a/src/versions.json b/src/versions.json new file mode 100644 index 0000000..7e61e08 --- /dev/null +++ b/src/versions.json @@ -0,0 +1,5 @@ +{ + "0.2.0": "1.0.0", + "0.3.0": "1.0.0", + "0.5.0": "1.0.0" +} \ No newline at end of file diff --git a/versions.json b/versions.json deleted file mode 100644 index 53be939..0000000 --- a/versions.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "0.2.0": "1.0.0", - "0.3.0": "1.0.0" -} \ No newline at end of file