From acbfb7b5c208bfa0ecce5e154ece1d6610a49c3b Mon Sep 17 00:00:00 2001 From: zihad Date: Thu, 10 Apr 2025 03:41:26 +0600 Subject: [PATCH] initial commit --- data.json | 6 + esbuild.config.mjs | 49 ++++++ main.js | 366 +++++++++++++++++++++++++++++++++++++++ main.ts | 414 +++++++++++++++++++++++++++++++++++++++++++++ manifest.json | 11 ++ package.json | 30 ++++ styles.css | 8 + tsconfig.json | 24 +++ version-bump.mjs | 14 ++ versions.json | 3 + 10 files changed, 925 insertions(+) create mode 100644 data.json create mode 100644 esbuild.config.mjs create mode 100644 main.js create mode 100644 main.ts create mode 100644 manifest.json create mode 100644 package.json create mode 100644 styles.css create mode 100644 tsconfig.json create mode 100644 version-bump.mjs create mode 100644 versions.json diff --git a/data.json b/data.json new file mode 100644 index 0000000..d7034d1 --- /dev/null +++ b/data.json @@ -0,0 +1,6 @@ +{ + "mySetting": "default", + "notesDB": [ + ], + "themeMode": "system" +} diff --git a/esbuild.config.mjs b/esbuild.config.mjs new file mode 100644 index 0000000..a5de8b8 --- /dev/null +++ b/esbuild.config.mjs @@ -0,0 +1,49 @@ +import esbuild from "esbuild"; +import process from "process"; +import builtins from "builtin-modules"; + +const banner = +`/* +THIS IS A GENERATED/BUNDLED FILE BY ESBUILD +if you want to view the source, please visit the github repository of this plugin +*/ +`; + +const prod = (process.argv[2] === "production"); + +const context = await esbuild.context({ + banner: { + js: banner, + }, + entryPoints: ["main.ts"], + bundle: true, + external: [ + "obsidian", + "electron", + "@codemirror/autocomplete", + "@codemirror/collab", + "@codemirror/commands", + "@codemirror/language", + "@codemirror/lint", + "@codemirror/search", + "@codemirror/state", + "@codemirror/view", + "@lezer/common", + "@lezer/highlight", + "@lezer/lr", + ...builtins], + format: "cjs", + target: "es2018", + logLevel: "info", + sourcemap: prod ? false : "inline", + treeShaking: true, + outfile: "main.js", + minify: prod, +}); + +if (prod) { + await context.rebuild(); + process.exit(0); +} else { + await context.watch(); +} diff --git a/main.js b/main.js new file mode 100644 index 0000000..c666a02 --- /dev/null +++ b/main.js @@ -0,0 +1,366 @@ +/* +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: () => MyPlugin +}); +module.exports = __toCommonJS(main_exports); +var import_obsidian = require("obsidian"); +var VIEW_TYPE_EASY_KEEP = "easy-keep-view"; +var DEFAULT_SETTINGS = { + mySetting: "default", + notesDB: [], + themeMode: "system" +}; +var EasyKeepView = class extends import_obsidian.ItemView { + constructor(leaf, plugin) { + super(leaf); + this.plugin = plugin; + } + getViewType() { + return VIEW_TYPE_EASY_KEEP; + } + getDisplayText() { + return "Easy Keep View"; + } + buildContent() { + this.mainContainer.empty(); + this.mainContainer.style.overflowY = "auto"; + this.mainContainer.style.height = "100%"; + const cardContainer = this.mainContainer.createDiv("easy-keep-cards-container"); + const newNoteCard = cardContainer.createDiv("easy-keep-card new-note-card"); + newNoteCard.createEl("h3", { text: "+" }); + newNoteCard.createEl("p", { text: "Add New Note" }); + newNoteCard.onclick = () => { + this.plugin.createNewNote(); + }; + let notes = this.plugin.settings.notesDB.slice().sort((a, b) => b.time - a.time).slice(0, 20); + if (notes.length) { + notes.forEach((note) => { + const card = cardContainer.createDiv("easy-keep-card"); + card.createEl("h3", { text: note.title }); + if (note.imagePath) { + const resourcePath = this.app.vault.adapter.getResourcePath(note.imagePath); + const img = card.createEl("img", { cls: "easy-keep-thumbnail" }); + img.src = resourcePath; + img.onerror = () => { + img.remove(); + if (note.excerpt) { + card.createEl("p", { text: note.excerpt }); + } + }; + img.onload = () => { + console.log(`[Render] Image loaded: ${resourcePath}`); + }; + } else { + if (note.excerpt) { + card.createEl("p", { text: note.excerpt }); + } + } + card.onclick = () => this.plugin.openNoteInNewTab(note.path); + }); + } else { + const noHistory = cardContainer.createDiv("no-history-message"); + noHistory.setText("No notes, create a new one!"); + } + this.injectCSS(); + } + refreshContent() { + this.buildContent(); + } + async onOpen() { + this.mainContainer = this.containerEl; + this.buildContent(); + } + async onClose() { + } + injectCSS() { + const existingStyle = document.getElementById("easy-keep-css"); + if (existingStyle) + existingStyle.remove(); + let bgColor = "#f9f9f9"; + let borderColor = "#ddd"; + let textColor = "#555"; + const theme = this.plugin.settings.themeMode; + if (theme === "dark" || theme === "system" && document.body.hasClass("theme-dark")) { + bgColor = "#333"; + borderColor = "#555"; + textColor = "#ccc"; + } + const style = document.createElement("style"); + style.id = "easy-keep-css"; + style.innerText = ` + .easy-keep-cards-container { + display: flex; + flex-wrap: wrap; + gap: 16px; + padding: 10px; + } + .easy-keep-card { + width: 250px; + min-height: 150px; + padding: 16px; + border: 1px solid ${borderColor}; + border-radius: 8px; + background-color: ${bgColor}; + box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1); + cursor: pointer; + color: ${textColor}; + display: flex; + flex-direction: column; + justify-content: space-between; + } + .easy-keep-card h3 { + font-size: 18px; + margin-bottom: 8px; + } + .easy-keep-card p { + font-size: 14px; + color: ${textColor}; + overflow: hidden; + text-overflow: ellipsis; + display: -webkit-box; + -webkit-line-clamp: 2; + -webkit-box-orient: vertical; + margin: 0; + } + .easy-keep-thumbnail { + max-width: 100%; + max-height: 100px; + object-fit: cover; + border-radius: 4px; + margin-top: 8px; + display: block; + } + .new-note-card { + width: 250px; + height: 150px; + display: flex; + align-items: center; + justify-content: center; + background-color: ${bgColor}; + border: 2px dashed ${borderColor}; + cursor: pointer; + } + .no-history-message { + font-size: 20px; + color: ${textColor}; + text-align: center; + padding: 20px; + width: 100%; + } + `; + document.head.appendChild(style); + } +}; +var SampleSettingTab = class extends import_obsidian.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + this.plugin = plugin; + } + display() { + const { containerEl } = this; + containerEl.empty(); + containerEl.createEl("h2", { text: "Easy Keep View Plugin Settings" }); + new import_obsidian.Setting(containerEl).setName("Theme Mode").setDesc("Select a theme mode for the Easy Keep View").addDropdown((dropdown) => { + dropdown.addOption("system", "System (adapt)"); + dropdown.addOption("light", "Light"); + dropdown.addOption("dark", "Dark"); + dropdown.setValue(this.plugin.settings.themeMode); + dropdown.onChange(async (value) => { + this.plugin.settings.themeMode = value; + await this.plugin.saveSettings(); + this.plugin.refreshEasyKeepViewIfOpen(); + }); + }); + } +}; +var MyPlugin = class extends import_obsidian.Plugin { + async onload() { + await this.loadSettings(); + await this.cleanDatabase(); + this.registerView(VIEW_TYPE_EASY_KEEP, (leaf) => new EasyKeepView(leaf, this)); + const ribbonIconEl = this.addRibbonIcon("dice", "Easy Keep View", () => { + this.activateEasyKeepView(); + }); + ribbonIconEl.addClass("my-plugin-ribbon-class"); + this.registerEvent(this.app.workspace.on("file-open", async (file) => { + if (file) { + await this.addToDatabase(file); + this.refreshEasyKeepViewIfOpen(); + } + })); + this.registerEvent(this.app.vault.on("delete", async (file) => { + if (file instanceof import_obsidian.TFile) { + await this.removeFromDatabase(file.path); + this.refreshEasyKeepViewIfOpen(); + } + })); + this.registerEvent(this.app.vault.on("rename", async (file, oldPath) => { + if (file instanceof import_obsidian.TFile) { + const entryIndex = this.settings.notesDB.findIndex((e) => e.path === oldPath); + if (entryIndex !== -1) { + this.settings.notesDB[entryIndex].path = file.path; + this.settings.notesDB[entryIndex].title = file.basename; + await this.saveSettings(); + this.refreshEasyKeepViewIfOpen(); + } + } + })); + this.registerEvent(this.app.vault.on("rename", async (file, oldPath) => { + if (file instanceof import_obsidian.TFile) { + const entryIndex = this.settings.notesDB.findIndex((e) => e.path === oldPath); + if (entryIndex !== -1) { + this.settings.notesDB[entryIndex].path = file.path; + this.settings.notesDB[entryIndex].title = file.basename; + await this.saveSettings(); + this.refreshEasyKeepViewIfOpen(); + } + if (/\.(jpg|jpeg|png|webp)$/i.test(file.path)) { + let updated = false; + this.settings.notesDB.forEach((entry) => { + if (entry.imagePath === oldPath) { + entry.imagePath = file.path; + updated = true; + } + }); + if (updated) { + await this.saveSettings(); + this.refreshEasyKeepViewIfOpen(); + } + } + } + })); + this.addSettingTab(new SampleSettingTab(this.app, this)); + } + onunload() { + this.app.workspace.detachLeavesOfType(VIEW_TYPE_EASY_KEEP); + } + async activateEasyKeepView() { + const existingLeaves = this.app.workspace.getLeavesOfType(VIEW_TYPE_EASY_KEEP); + if (existingLeaves.length > 0) { + this.app.workspace.revealLeaf(existingLeaves[0]); + return; + } + const leaf = this.app.workspace.getLeaf(true); + await leaf.setViewState({ type: VIEW_TYPE_EASY_KEEP, active: true }); + this.app.workspace.revealLeaf(leaf); + } + refreshEasyKeepViewIfOpen() { + const existingLeaves = this.app.workspace.getLeavesOfType(VIEW_TYPE_EASY_KEEP); + if (existingLeaves.length > 0) { + const view = existingLeaves[0].view; + view.refreshContent(); + } + } + async addToDatabase(file) { + const content = await this.app.vault.cachedRead(file); + const lines = content.trim().split("\n").filter((line) => line.trim() !== ""); + let excerpt = ""; + let imagePath; + if (/\.(jpg|jpeg|png|webp)$/i.test(file.path)) { + imagePath = file.path; + } else { + const imageMatch = content.match(/!\[.*?\]\((.*?)\)|\!\[\[(.*?)\]\]/i); + if (imageMatch) { + imagePath = imageMatch[1] || imageMatch[2]; + if (imagePath && !imagePath.startsWith("http") && !imagePath.startsWith("/")) { + const fileFolder = file.path.substring(0, file.path.lastIndexOf("/")); + imagePath = `${fileFolder}/${imagePath}`.replace(/\/+/g, "/"); + } + const imageFile = this.app.vault.getAbstractFileByPath(imagePath); + if (!(imageFile instanceof import_obsidian.TFile && /\.(jpg|jpeg|png|webp)$/i.test(imagePath))) { + imagePath = void 0; + } + } + } + if (!imagePath && lines.length > 0) { + excerpt = lines.slice(0, 2).join(" "); + if (lines.length > 2) + excerpt = excerpt.trim() + " \u2026"; + } + const titleWithoutExt = file.name.replace(/\.(md|png|jpg|jpeg|webp)$/i, ""); + const newEntry = { + path: file.path, + title: titleWithoutExt, + excerpt, + time: Date.now(), + imagePath + }; + this.settings.notesDB = this.settings.notesDB.filter((entry) => entry.path !== file.path); + this.settings.notesDB.unshift(newEntry); + await this.saveSettings(); + } + async removeFromDatabase(filePath) { + const initialLength = this.settings.notesDB.length; + this.settings.notesDB = this.settings.notesDB.filter((entry) => entry.path !== filePath); + if (this.settings.notesDB.length !== initialLength) { + await this.saveSettings(); + } + } + async cleanDatabase() { + const files = this.app.vault.getMarkdownFiles(); + const existingPaths = new Set(files.map((file) => file.path)); + this.settings.notesDB = this.settings.notesDB.filter((entry) => existingPaths.has(entry.path)); + await this.saveSettings(); + } + async openNoteInNewTab(filePath) { + const file = this.app.vault.getAbstractFileByPath(filePath); + if (!(file instanceof import_obsidian.TFile)) + return; + let existingLeaf = null; + this.app.workspace.iterateAllLeaves((leaf) => { + var _a; + if (leaf.view.getViewType() === "markdown" && ((_a = leaf.view.file) == null ? void 0 : _a.path) === filePath) { + existingLeaf = leaf; + } + }); + if (existingLeaf) { + this.app.workspace.setActiveLeaf(existingLeaf, { focus: true }); + } else { + const newLeaf = this.app.workspace.getLeaf(true); + await newLeaf.openFile(file); + this.app.workspace.setActiveLeaf(newLeaf, { focus: true }); + } + } + async loadSettings() { + this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData()); + } + async saveSettings() { + await this.saveData(this.settings); + } + async createNewNote() { + const fileName = `New Note ${Date.now()}.md`; + const filePath = `/${fileName}`; + const file = await this.app.vault.create(filePath, `# ${fileName} +`); + await this.addToDatabase(file); + this.refreshEasyKeepViewIfOpen(); + const newLeaf = this.app.workspace.getLeaf(true); + await newLeaf.openFile(file); + this.app.workspace.setActiveLeaf(newLeaf, { focus: true }); + } +}; +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["main.ts"],
  "sourcesContent": ["import {\n\tApp,\n\tPlugin,\n\tNotice,\n\tWorkspaceLeaf,\n\tItemView,\n\tTFile,\n\tPluginSettingTab,\n\tSetting,\n} from \"obsidian\";\n\nconst VIEW_TYPE_EASY_KEEP = \"easy-keep-view\";\n\ninterface NoteEntry {\n\tpath: string;\n\ttitle: string;\n\texcerpt: string;\n\ttime: number;\n\timagePath?: string;\n}\n\ninterface MyPluginSettings {\n\tmySetting: string;\n\tnotesDB: NoteEntry[];\n\tthemeMode: \"system\" | \"light\" | \"dark\";\n}\n\nconst DEFAULT_SETTINGS: MyPluginSettings = {\n\tmySetting: \"default\",\n\tnotesDB: [],\n\tthemeMode: \"system\",\n};\n\nclass EasyKeepView extends ItemView {\n\tplugin: MyPlugin;\n\tprivate mainContainer: HTMLElement;\n\n\tconstructor(leaf: WorkspaceLeaf, plugin: MyPlugin) {\n\t\tsuper(leaf);\n\t\tthis.plugin = plugin;\n\t}\n\n\tgetViewType(): string {\n\t\treturn VIEW_TYPE_EASY_KEEP;\n\t}\n\n\tgetDisplayText(): string {\n\t\treturn \"Easy Keep View\";\n\t}\n\n\tbuildContent() {\n\t\tthis.mainContainer.empty();\n\t\tthis.mainContainer.style.overflowY = \"auto\";\n\t\tthis.mainContainer.style.height = \"100%\";\n\n\t\tconst cardContainer = this.mainContainer.createDiv(\"easy-keep-cards-container\");\n\n\t\tconst newNoteCard = cardContainer.createDiv(\"easy-keep-card new-note-card\");\n\t\tnewNoteCard.createEl(\"h3\", { text: \"+\" });\n\t\tnewNoteCard.createEl(\"p\", { text: \"Add New Note\" });\n\n\t\tnewNoteCard.onclick = () => {\n\t\t\tthis.plugin.createNewNote();\n\t\t};\n\n\t\tlet notes = this.plugin.settings.notesDB.slice().sort((a, b) => b.time - a.time).slice(0, 20);\n\n\t\tif (notes.length) {\n\t\t\tnotes.forEach(note => {\n\t\t\t\tconst card = cardContainer.createDiv(\"easy-keep-card\");\n\t\t\t\tcard.createEl(\"h3\", { text: note.title });\n\n\t\t\t\tif (note.imagePath) {\n\t\t\t\t\tconst resourcePath = this.app.vault.adapter.getResourcePath(note.imagePath);\n\t\t\t\t\tconst img = card.createEl(\"img\", { cls: \"easy-keep-thumbnail\" });\n\t\t\t\t\timg.src = resourcePath;\n\n\t\t\t\t\timg.onerror = () => {\n\t\t\t\t\t\timg.remove();\n\t\t\t\t\t\tif (note.excerpt) {\n\t\t\t\t\t\t\tcard.createEl(\"p\", { text: note.excerpt });\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\n\t\t\t\t\timg.onload = () => {\n\t\t\t\t\t\tconsole.log(`[Render] Image loaded: ${resourcePath}`);\n\t\t\t\t\t};\n\t\t\t\t} else {\n\t\t\t\t\tif (note.excerpt) {\n\t\t\t\t\t\tcard.createEl(\"p\", { text: note.excerpt });\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tcard.onclick = () => this.plugin.openNoteInNewTab(note.path);\n\t\t\t});\n\t\t} else {\n\t\t\tconst noHistory = cardContainer.createDiv(\"no-history-message\");\n\t\t\tnoHistory.setText(\"No notes, create a new one!\");\n\t\t}\n\n\t\tthis.injectCSS();\n\t}\n\n\trefreshContent() {\n\t\tthis.buildContent();\n\t}\n\n\tasync onOpen() {\n\t\tthis.mainContainer = this.containerEl;\n\t\tthis.buildContent();\n\t}\n\n\tasync onClose() {}\n\n\tinjectCSS() {\n\t\tconst existingStyle = document.getElementById(\"easy-keep-css\");\n\t\tif (existingStyle) existingStyle.remove();\n\n\t\tlet bgColor = \"#f9f9f9\";\n\t\tlet borderColor = \"#ddd\";\n\t\tlet textColor = \"#555\";\n\t\tconst theme = this.plugin.settings.themeMode;\n\n\t\tif (theme === \"dark\" || (theme === \"system\" && document.body.hasClass(\"theme-dark\"))) {\n\t\t\tbgColor = \"#333\";\n\t\t\tborderColor = \"#555\";\n\t\t\ttextColor = \"#ccc\";\n\t\t}\n\n\t\tconst style = document.createElement(\"style\");\n\t\tstyle.id = \"easy-keep-css\";\n\t\tstyle.innerText = `\n\t\t.easy-keep-cards-container {\n\t\t\tdisplay: flex;\n\t\t\tflex-wrap: wrap;\n\t\t\tgap: 16px;\n\t\t\tpadding: 10px;\n\t\t}\n\t\t.easy-keep-card {\n\t\t\twidth: 250px;\n\t\t\tmin-height: 150px;\n\t\t\tpadding: 16px;\n\t\t\tborder: 1px solid ${borderColor};\n\t\t\tborder-radius: 8px;\n\t\t\tbackground-color: ${bgColor};\n\t\t\tbox-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);\n\t\t\tcursor: pointer;\n\t\t\tcolor: ${textColor};\n\t\t\tdisplay: flex;\n\t\t\tflex-direction: column;\n\t\t\tjustify-content: space-between;\n\t\t}\n\t\t.easy-keep-card h3 {\n\t\t\tfont-size: 18px;\n\t\t\tmargin-bottom: 8px;\n\t\t}\n\t\t.easy-keep-card p {\n\t\t\tfont-size: 14px;\n\t\t\tcolor: ${textColor};\n\t\t\toverflow: hidden;\n\t\t\ttext-overflow: ellipsis;\n\t\t\tdisplay: -webkit-box;\n\t\t\t-webkit-line-clamp: 2;\n\t\t\t-webkit-box-orient: vertical;\n\t\t\tmargin: 0;\n\t\t}\n\t\t.easy-keep-thumbnail {\n\t\t\tmax-width: 100%;\n\t\t\tmax-height: 100px;\n\t\t\tobject-fit: cover;\n\t\t\tborder-radius: 4px;\n\t\t\tmargin-top: 8px;\n\t\t\tdisplay: block;\n\t\t}\n\t\t.new-note-card {\n\t\t\twidth: 250px;\n\t\t\theight: 150px;\n\t\t\tdisplay: flex;\n\t\t\talign-items: center;\n\t\t\tjustify-content: center;\n\t\t\tbackground-color: ${bgColor};\n\t\t\tborder: 2px dashed ${borderColor};\n\t\t\tcursor: pointer;\n\t\t}\n\t\t.no-history-message {\n\t\t\tfont-size: 20px;\n\t\t\tcolor: ${textColor};\n\t\t\ttext-align: center;\n\t\t\tpadding: 20px;\n\t\t\twidth: 100%;\n\t\t}\n\t\t`;\n\t\tdocument.head.appendChild(style);\n\t}\n}\n\nclass SampleSettingTab extends PluginSettingTab {\n\tplugin: MyPlugin;\n\tconstructor(app: App, plugin: MyPlugin) {\n\t\tsuper(app, plugin);\n\t\tthis.plugin = plugin;\n\t}\n\tdisplay(): void {\n\t\tconst { containerEl } = this;\n\t\tcontainerEl.empty();\n\t\tcontainerEl.createEl(\"h2\", { text: \"Easy Keep View Plugin Settings\" });\n\t\tnew Setting(containerEl)\n\t\t.setName(\"Theme Mode\")\n\t\t.setDesc(\"Select a theme mode for the Easy Keep View\")\n\t\t.addDropdown(dropdown => {\n\t\t\tdropdown.addOption(\"system\", \"System (adapt)\");\n\t\t\tdropdown.addOption(\"light\", \"Light\");\n\t\t\tdropdown.addOption(\"dark\", \"Dark\");\n\t\t\tdropdown.setValue(this.plugin.settings.themeMode);\n\t\t\tdropdown.onChange(async (value: \"system\" | \"light\" | \"dark\") => {\n\t\t\t\tthis.plugin.settings.themeMode = value;\n\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\tthis.plugin.refreshEasyKeepViewIfOpen();\n\t\t\t});\n\t\t});\n\t}\n}\n\nexport default class MyPlugin extends Plugin {\n\tsettings: MyPluginSettings;\n\n\tasync onload() {\n\t\tawait this.loadSettings();\n\t\tawait this.cleanDatabase();\n\n\t\tthis.registerView(VIEW_TYPE_EASY_KEEP, (leaf) => new EasyKeepView(leaf, this));\n\n\t\tconst ribbonIconEl = this.addRibbonIcon(\"dice\", \"Easy Keep View\", () => {\n\t\t\tthis.activateEasyKeepView();\n\t\t});\n\t\tribbonIconEl.addClass(\"my-plugin-ribbon-class\");\n\n\t\tthis.registerEvent(this.app.workspace.on(\"file-open\", async (file) => {\n\t\t\tif (file) {\n\t\t\t\tawait this.addToDatabase(file);\n\t\t\t\tthis.refreshEasyKeepViewIfOpen();\n\t\t\t}\n\t\t}));\n\n\t\tthis.registerEvent(this.app.vault.on(\"delete\", async (file) => {\n\t\t\tif (file instanceof TFile) {\n\t\t\t\tawait this.removeFromDatabase(file.path);\n\t\t\t\tthis.refreshEasyKeepViewIfOpen();\n\t\t\t}\n\t\t}));\n\n\t\tthis.registerEvent(this.app.vault.on(\"rename\", async (file, oldPath) => {\n\t\t\tif (file instanceof TFile) {\n\t\t\t\tconst entryIndex = this.settings.notesDB.findIndex(e => e.path === oldPath);\n\t\t\t\tif (entryIndex !== -1) {\n\t\t\t\t\tthis.settings.notesDB[entryIndex].path = file.path;\n\t\t\t\t\tthis.settings.notesDB[entryIndex].title = file.basename;\n\t\t\t\t\tawait this.saveSettings();\n\t\t\t\t\tthis.refreshEasyKeepViewIfOpen();\n\t\t\t\t}\n\t\t\t}\n\t\t}));\n\n\t\tthis.registerEvent(this.app.vault.on(\"rename\", async (file, oldPath) => {\n\t\t\tif (file instanceof TFile) {\n\t\t\t\t// Update renamed note file\n\t\t\t\tconst entryIndex = this.settings.notesDB.findIndex(e => e.path === oldPath);\n\t\t\t\tif (entryIndex !== -1) {\n\t\t\t\t\tthis.settings.notesDB[entryIndex].path = file.path;\n\t\t\t\t\tthis.settings.notesDB[entryIndex].title = file.basename;\n\t\t\t\t\tawait this.saveSettings();\n\t\t\t\t\tthis.refreshEasyKeepViewIfOpen();\n\t\t\t\t}\n\n\t\t\t\t// Update renamed image file\n\t\t\t\tif (/\\.(jpg|jpeg|png|webp)$/i.test(file.path)) {\n\t\t\t\t\tlet updated = false;\n\t\t\t\t\tthis.settings.notesDB.forEach(entry => {\n\t\t\t\t\t\tif (entry.imagePath === oldPath) {\n\t\t\t\t\t\t\tentry.imagePath = file.path;\n\t\t\t\t\t\t\tupdated = true;\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t\tif (updated) {\n\t\t\t\t\t\tawait this.saveSettings();\n\t\t\t\t\t\tthis.refreshEasyKeepViewIfOpen();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}));\n\n\t\tthis.addSettingTab(new SampleSettingTab(this.app, this));\n\t}\n\n\tonunload() {\n\t\tthis.app.workspace.detachLeavesOfType(VIEW_TYPE_EASY_KEEP);\n\t}\n\n\tasync activateEasyKeepView() {\n\t\tconst existingLeaves = this.app.workspace.getLeavesOfType(VIEW_TYPE_EASY_KEEP);\n\t\tif (existingLeaves.length > 0) {\n\t\t\tthis.app.workspace.revealLeaf(existingLeaves[0]);\n\t\t\treturn;\n\t\t}\n\n\t\tconst leaf = this.app.workspace.getLeaf(true);\n\t\tawait leaf.setViewState({ type: VIEW_TYPE_EASY_KEEP, active: true });\n\t\tthis.app.workspace.revealLeaf(leaf);\n\t}\n\n\trefreshEasyKeepViewIfOpen() {\n\t\tconst existingLeaves = this.app.workspace.getLeavesOfType(VIEW_TYPE_EASY_KEEP);\n\t\tif (existingLeaves.length > 0) {\n\t\t\tconst view = existingLeaves[0].view as EasyKeepView;\n\t\t\tview.refreshContent();\n\t\t}\n\t}\n\n\tasync addToDatabase(file: TFile) {\n\t\tconst content = await this.app.vault.cachedRead(file);\n\t\tconst lines = content.trim().split(\"\\n\").filter(line => line.trim() !== \"\");\n\t\tlet excerpt = \"\";\n\t\tlet imagePath: string | undefined;\n\n\t\tif (/\\.(jpg|jpeg|png|webp)$/i.test(file.path)) {\n\t\t\timagePath = file.path;\n\t\t} else {\n\t\t\tconst imageMatch = content.match(/!\\[.*?\\]\\((.*?)\\)|\\!\\[\\[(.*?)\\]\\]/i);\n\t\t\tif (imageMatch) {\n\t\t\t\timagePath = imageMatch[1] || imageMatch[2];\n\t\t\t\tif (imagePath && !imagePath.startsWith(\"http\") && !imagePath.startsWith(\"/\")) {\n\t\t\t\t\tconst fileFolder = file.path.substring(0, file.path.lastIndexOf(\"/\"));\n\t\t\t\t\timagePath = `${fileFolder}/${imagePath}`.replace(/\\/+/g, \"/\");\n\t\t\t\t}\n\t\t\t\tconst imageFile = this.app.vault.getAbstractFileByPath(imagePath);\n\t\t\t\tif (!(imageFile instanceof TFile && /\\.(jpg|jpeg|png|webp)$/i.test(imagePath))) {\n\t\t\t\t\timagePath = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (!imagePath && lines.length > 0) {\n\t\t\texcerpt = lines.slice(0, 2).join(\" \");\n\t\t\tif (lines.length > 2) excerpt = excerpt.trim() + \" \u2026\";\n\t\t}\n\n\t\tconst titleWithoutExt = file.name.replace(/\\.(md|png|jpg|jpeg|webp)$/i, \"\");\n\t\tconst newEntry: NoteEntry = {\n\t\t\tpath: file.path,\n\t\t\ttitle: titleWithoutExt,\n\t\t\texcerpt,\n\t\t\ttime: Date.now(),\n\t\t\timagePath,\n\t\t};\n\n\t\tthis.settings.notesDB = this.settings.notesDB.filter(entry => entry.path !== file.path);\n\t\tthis.settings.notesDB.unshift(newEntry);\n\t\tawait this.saveSettings();\n\t}\n\n\tasync removeFromDatabase(filePath: string) {\n\t\tconst initialLength = this.settings.notesDB.length;\n\t\tthis.settings.notesDB = this.settings.notesDB.filter(entry => entry.path !== filePath);\n\t\tif (this.settings.notesDB.length !== initialLength) {\n\t\t\tawait this.saveSettings();\n\t\t}\n\t}\n\n\tasync cleanDatabase() {\n\t\tconst files = this.app.vault.getMarkdownFiles();\n\t\tconst existingPaths = new Set(files.map(file => file.path));\n\t\tthis.settings.notesDB = this.settings.notesDB.filter(entry => existingPaths.has(entry.path));\n\t\tawait this.saveSettings();\n\t}\n\n\tasync openNoteInNewTab(filePath: string) {\n\t\tconst file = this.app.vault.getAbstractFileByPath(filePath);\n\t\tif (!(file instanceof TFile)) return;\n\n\t\tlet existingLeaf: WorkspaceLeaf | null = null;\n\t\tthis.app.workspace.iterateAllLeaves(leaf => {\n\t\t\tif (leaf.view.getViewType() === \"markdown\" && (leaf.view as any).file?.path === filePath) {\n\t\t\t\texistingLeaf = leaf;\n\t\t\t}\n\t\t});\n\n\t\tif (existingLeaf) {\n\t\t\tthis.app.workspace.setActiveLeaf(existingLeaf, { focus: true });\n\t\t} else {\n\t\t\tconst newLeaf = this.app.workspace.getLeaf(true);\n\t\t\tawait newLeaf.openFile(file);\n\t\t\tthis.app.workspace.setActiveLeaf(newLeaf, { focus: true });\n\t\t}\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\tasync createNewNote() {\n\t\tconst fileName = `New Note ${Date.now()}.md`;\n\t\tconst filePath = `/${fileName}`;\n\t\tconst file = await this.app.vault.create(filePath, `# ${fileName}\\n`);\n\t\tawait this.addToDatabase(file);\n\t\tthis.refreshEasyKeepViewIfOpen();\n\t\tconst newLeaf = this.app.workspace.getLeaf(true);\n\t\tawait newLeaf.openFile(file);\n\t\tthis.app.workspace.setActiveLeaf(newLeaf, { focus: true });\n\t}\n}\n"],
  "mappings": "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",
  "names": []
}
 diff --git a/main.ts b/main.ts new file mode 100644 index 0000000..5d783ca --- /dev/null +++ b/main.ts @@ -0,0 +1,414 @@ +import { + App, + Plugin, + Notice, + WorkspaceLeaf, + ItemView, + TFile, + PluginSettingTab, + Setting, +} from "obsidian"; + +const VIEW_TYPE_EASY_KEEP = "easy-keep-view"; + +interface NoteEntry { + path: string; + title: string; + excerpt: string; + time: number; + imagePath?: string; +} + +interface MyPluginSettings { + mySetting: string; + notesDB: NoteEntry[]; + themeMode: "system" | "light" | "dark"; +} + +const DEFAULT_SETTINGS: MyPluginSettings = { + mySetting: "default", + notesDB: [], + themeMode: "system", +}; + +class EasyKeepView extends ItemView { + plugin: MyPlugin; + private mainContainer: HTMLElement; + + constructor(leaf: WorkspaceLeaf, plugin: MyPlugin) { + super(leaf); + this.plugin = plugin; + } + + getViewType(): string { + return VIEW_TYPE_EASY_KEEP; + } + + getDisplayText(): string { + return "Easy Keep View"; + } + + buildContent() { + this.mainContainer.empty(); + this.mainContainer.style.overflowY = "auto"; + this.mainContainer.style.height = "100%"; + + const cardContainer = this.mainContainer.createDiv("easy-keep-cards-container"); + + const newNoteCard = cardContainer.createDiv("easy-keep-card new-note-card"); + newNoteCard.createEl("h3", { text: "+" }); + newNoteCard.createEl("p", { text: "Add New Note" }); + + newNoteCard.onclick = () => { + this.plugin.createNewNote(); + }; + + let notes = this.plugin.settings.notesDB.slice().sort((a, b) => b.time - a.time).slice(0, 20); + + if (notes.length) { + notes.forEach(note => { + const card = cardContainer.createDiv("easy-keep-card"); + card.createEl("h3", { text: note.title }); + + if (note.imagePath) { + const resourcePath = this.app.vault.adapter.getResourcePath(note.imagePath); + const img = card.createEl("img", { cls: "easy-keep-thumbnail" }); + img.src = resourcePath; + + img.onerror = () => { + img.remove(); + if (note.excerpt) { + card.createEl("p", { text: note.excerpt }); + } + }; + + img.onload = () => { + console.log(`[Render] Image loaded: ${resourcePath}`); + }; + } else { + if (note.excerpt) { + card.createEl("p", { text: note.excerpt }); + } + } + + card.onclick = () => this.plugin.openNoteInNewTab(note.path); + }); + } else { + const noHistory = cardContainer.createDiv("no-history-message"); + noHistory.setText("No notes, create a new one!"); + } + + this.injectCSS(); + } + + refreshContent() { + this.buildContent(); + } + + async onOpen() { + this.mainContainer = this.containerEl; + this.buildContent(); + } + + async onClose() {} + + injectCSS() { + const existingStyle = document.getElementById("easy-keep-css"); + if (existingStyle) existingStyle.remove(); + + let bgColor = "#f9f9f9"; + let borderColor = "#ddd"; + let textColor = "#555"; + const theme = this.plugin.settings.themeMode; + + if (theme === "dark" || (theme === "system" && document.body.hasClass("theme-dark"))) { + bgColor = "#333"; + borderColor = "#555"; + textColor = "#ccc"; + } + + const style = document.createElement("style"); + style.id = "easy-keep-css"; + style.innerText = ` + .easy-keep-cards-container { + display: flex; + flex-wrap: wrap; + gap: 16px; + padding: 10px; + } + .easy-keep-card { + width: 250px; + min-height: 150px; + padding: 16px; + border: 1px solid ${borderColor}; + border-radius: 8px; + background-color: ${bgColor}; + box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1); + cursor: pointer; + color: ${textColor}; + display: flex; + flex-direction: column; + justify-content: space-between; + } + .easy-keep-card h3 { + font-size: 18px; + margin-bottom: 8px; + } + .easy-keep-card p { + font-size: 14px; + color: ${textColor}; + overflow: hidden; + text-overflow: ellipsis; + display: -webkit-box; + -webkit-line-clamp: 2; + -webkit-box-orient: vertical; + margin: 0; + } + .easy-keep-thumbnail { + max-width: 100%; + max-height: 100px; + object-fit: cover; + border-radius: 4px; + margin-top: 8px; + display: block; + } + .new-note-card { + width: 250px; + height: 150px; + display: flex; + align-items: center; + justify-content: center; + background-color: ${bgColor}; + border: 2px dashed ${borderColor}; + cursor: pointer; + } + .no-history-message { + font-size: 20px; + color: ${textColor}; + text-align: center; + padding: 20px; + width: 100%; + } + `; + document.head.appendChild(style); + } +} + +class SampleSettingTab extends PluginSettingTab { + plugin: MyPlugin; + constructor(app: App, plugin: MyPlugin) { + super(app, plugin); + this.plugin = plugin; + } + display(): void { + const { containerEl } = this; + containerEl.empty(); + containerEl.createEl("h2", { text: "Easy Keep View Plugin Settings" }); + new Setting(containerEl) + .setName("Theme Mode") + .setDesc("Select a theme mode for the Easy Keep View") + .addDropdown(dropdown => { + dropdown.addOption("system", "System (adapt)"); + dropdown.addOption("light", "Light"); + dropdown.addOption("dark", "Dark"); + dropdown.setValue(this.plugin.settings.themeMode); + dropdown.onChange(async (value: "system" | "light" | "dark") => { + this.plugin.settings.themeMode = value; + await this.plugin.saveSettings(); + this.plugin.refreshEasyKeepViewIfOpen(); + }); + }); + } +} + +export default class MyPlugin extends Plugin { + settings: MyPluginSettings; + + async onload() { + await this.loadSettings(); + await this.cleanDatabase(); + + this.registerView(VIEW_TYPE_EASY_KEEP, (leaf) => new EasyKeepView(leaf, this)); + + const ribbonIconEl = this.addRibbonIcon("dice", "Easy Keep View", () => { + this.activateEasyKeepView(); + }); + ribbonIconEl.addClass("my-plugin-ribbon-class"); + + this.registerEvent(this.app.workspace.on("file-open", async (file) => { + if (file) { + await this.addToDatabase(file); + this.refreshEasyKeepViewIfOpen(); + } + })); + + this.registerEvent(this.app.vault.on("delete", async (file) => { + if (file instanceof TFile) { + await this.removeFromDatabase(file.path); + this.refreshEasyKeepViewIfOpen(); + } + })); + + this.registerEvent(this.app.vault.on("rename", async (file, oldPath) => { + if (file instanceof TFile) { + const entryIndex = this.settings.notesDB.findIndex(e => e.path === oldPath); + if (entryIndex !== -1) { + this.settings.notesDB[entryIndex].path = file.path; + this.settings.notesDB[entryIndex].title = file.basename; + await this.saveSettings(); + this.refreshEasyKeepViewIfOpen(); + } + } + })); + + this.registerEvent(this.app.vault.on("rename", async (file, oldPath) => { + if (file instanceof TFile) { + // Update renamed note file + const entryIndex = this.settings.notesDB.findIndex(e => e.path === oldPath); + if (entryIndex !== -1) { + this.settings.notesDB[entryIndex].path = file.path; + this.settings.notesDB[entryIndex].title = file.basename; + await this.saveSettings(); + this.refreshEasyKeepViewIfOpen(); + } + + // Update renamed image file + if (/\.(jpg|jpeg|png|webp)$/i.test(file.path)) { + let updated = false; + this.settings.notesDB.forEach(entry => { + if (entry.imagePath === oldPath) { + entry.imagePath = file.path; + updated = true; + } + }); + if (updated) { + await this.saveSettings(); + this.refreshEasyKeepViewIfOpen(); + } + } + } + })); + + this.addSettingTab(new SampleSettingTab(this.app, this)); + } + + onunload() { + this.app.workspace.detachLeavesOfType(VIEW_TYPE_EASY_KEEP); + } + + async activateEasyKeepView() { + const existingLeaves = this.app.workspace.getLeavesOfType(VIEW_TYPE_EASY_KEEP); + if (existingLeaves.length > 0) { + this.app.workspace.revealLeaf(existingLeaves[0]); + return; + } + + const leaf = this.app.workspace.getLeaf(true); + await leaf.setViewState({ type: VIEW_TYPE_EASY_KEEP, active: true }); + this.app.workspace.revealLeaf(leaf); + } + + refreshEasyKeepViewIfOpen() { + const existingLeaves = this.app.workspace.getLeavesOfType(VIEW_TYPE_EASY_KEEP); + if (existingLeaves.length > 0) { + const view = existingLeaves[0].view as EasyKeepView; + view.refreshContent(); + } + } + + async addToDatabase(file: TFile) { + const content = await this.app.vault.cachedRead(file); + const lines = content.trim().split("\n").filter(line => line.trim() !== ""); + let excerpt = ""; + let imagePath: string | undefined; + + if (/\.(jpg|jpeg|png|webp)$/i.test(file.path)) { + imagePath = file.path; + } else { + const imageMatch = content.match(/!\[.*?\]\((.*?)\)|\!\[\[(.*?)\]\]/i); + if (imageMatch) { + imagePath = imageMatch[1] || imageMatch[2]; + if (imagePath && !imagePath.startsWith("http") && !imagePath.startsWith("/")) { + const fileFolder = file.path.substring(0, file.path.lastIndexOf("/")); + imagePath = `${fileFolder}/${imagePath}`.replace(/\/+/g, "/"); + } + const imageFile = this.app.vault.getAbstractFileByPath(imagePath); + if (!(imageFile instanceof TFile && /\.(jpg|jpeg|png|webp)$/i.test(imagePath))) { + imagePath = undefined; + } + } + } + + if (!imagePath && lines.length > 0) { + excerpt = lines.slice(0, 2).join(" "); + if (lines.length > 2) excerpt = excerpt.trim() + " …"; + } + + const titleWithoutExt = file.name.replace(/\.(md|png|jpg|jpeg|webp)$/i, ""); + const newEntry: NoteEntry = { + path: file.path, + title: titleWithoutExt, + excerpt, + time: Date.now(), + imagePath, + }; + + this.settings.notesDB = this.settings.notesDB.filter(entry => entry.path !== file.path); + this.settings.notesDB.unshift(newEntry); + await this.saveSettings(); + } + + async removeFromDatabase(filePath: string) { + const initialLength = this.settings.notesDB.length; + this.settings.notesDB = this.settings.notesDB.filter(entry => entry.path !== filePath); + if (this.settings.notesDB.length !== initialLength) { + await this.saveSettings(); + } + } + + async cleanDatabase() { + const files = this.app.vault.getMarkdownFiles(); + const existingPaths = new Set(files.map(file => file.path)); + this.settings.notesDB = this.settings.notesDB.filter(entry => existingPaths.has(entry.path)); + await this.saveSettings(); + } + + async openNoteInNewTab(filePath: string) { + const file = this.app.vault.getAbstractFileByPath(filePath); + if (!(file instanceof TFile)) return; + + let existingLeaf: WorkspaceLeaf | null = null; + this.app.workspace.iterateAllLeaves(leaf => { + if (leaf.view.getViewType() === "markdown" && (leaf.view as any).file?.path === filePath) { + existingLeaf = leaf; + } + }); + + if (existingLeaf) { + this.app.workspace.setActiveLeaf(existingLeaf, { focus: true }); + } else { + const newLeaf = this.app.workspace.getLeaf(true); + await newLeaf.openFile(file); + this.app.workspace.setActiveLeaf(newLeaf, { focus: true }); + } + } + + async loadSettings() { + this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData()); + } + + async saveSettings() { + await this.saveData(this.settings); + } + + async createNewNote() { + const fileName = `New Note ${Date.now()}.md`; + const filePath = `/${fileName}`; + const file = await this.app.vault.create(filePath, `# ${fileName}\n`); + await this.addToDatabase(file); + this.refreshEasyKeepViewIfOpen(); + const newLeaf = this.app.workspace.getLeaf(true); + await newLeaf.openFile(file); + this.app.workspace.setActiveLeaf(newLeaf, { focus: true }); + } +} diff --git a/manifest.json b/manifest.json new file mode 100644 index 0000000..dfa940e --- /dev/null +++ b/manifest.json @@ -0,0 +1,11 @@ +{ + "id": "sample-plugin", + "name": "Sample Plugin", + "version": "1.0.0", + "minAppVersion": "0.15.0", + "description": "Demonstrates some of the capabilities of the Obsidian API.", + "author": "Obsidian", + "authorUrl": "https://obsidian.md", + "fundingUrl": "https://obsidian.md/pricing", + "isDesktopOnly": false +} diff --git a/package.json b/package.json new file mode 100644 index 0000000..f2c551f --- /dev/null +++ b/package.json @@ -0,0 +1,30 @@ +{ + "name": "obsidian-easy-keep-view", + "version": "1.0.0", + "description": "An Obsidian plugin for mimicking the Google Keep interface, allowing you to view and manage your notes with image thumbnails and excerpts.", + "main": "main.js", + "scripts": { + "dev": "node esbuild.config.mjs", + "build": "tsc -noEmit -skipLibCheck && node esbuild.config.mjs production", + "version": "node version-bump.mjs && git add manifest.json versions.json" + }, + "keywords": [ + "obsidian", + "plugin", + "notes", + "google keep", + "easy keep view" + ], + "author": "@tazihad", + "license": "MIT", + "devDependencies": { + "@types/node": "^16.11.6", + "@typescript-eslint/eslint-plugin": "5.29.0", + "@typescript-eslint/parser": "5.29.0", + "builtin-modules": "3.3.0", + "esbuild": "0.17.3", + "obsidian": "latest", + "tslib": "2.4.0", + "typescript": "4.7.4" + } +} diff --git a/styles.css b/styles.css new file mode 100644 index 0000000..71cc60f --- /dev/null +++ b/styles.css @@ -0,0 +1,8 @@ +/* + +This CSS file will be included with your plugin, and +available in the app when your plugin is enabled. + +If your plugin does not need CSS, delete this file. + +*/ diff --git a/tsconfig.json b/tsconfig.json new file mode 100644 index 0000000..c44b729 --- /dev/null +++ b/tsconfig.json @@ -0,0 +1,24 @@ +{ + "compilerOptions": { + "baseUrl": ".", + "inlineSourceMap": true, + "inlineSources": true, + "module": "ESNext", + "target": "ES6", + "allowJs": true, + "noImplicitAny": true, + "moduleResolution": "node", + "importHelpers": true, + "isolatedModules": true, + "strictNullChecks": true, + "lib": [ + "DOM", + "ES5", + "ES6", + "ES7" + ] + }, + "include": [ + "**/*.ts" + ] +} diff --git a/version-bump.mjs b/version-bump.mjs new file mode 100644 index 0000000..d409fa0 --- /dev/null +++ b/version-bump.mjs @@ -0,0 +1,14 @@ +import { readFileSync, writeFileSync } from "fs"; + +const targetVersion = process.env.npm_package_version; + +// read minAppVersion from manifest.json and bump version to target version +let manifest = JSON.parse(readFileSync("manifest.json", "utf8")); +const { minAppVersion } = manifest; +manifest.version = targetVersion; +writeFileSync("manifest.json", JSON.stringify(manifest, null, "\t")); + +// update versions.json with target version and minAppVersion from manifest.json +let versions = JSON.parse(readFileSync("versions.json", "utf8")); +versions[targetVersion] = minAppVersion; +writeFileSync("versions.json", JSON.stringify(versions, null, "\t")); diff --git a/versions.json b/versions.json new file mode 100644 index 0000000..479cc62 --- /dev/null +++ b/versions.json @@ -0,0 +1,3 @@ +{ + "0.0.1": "1.0.0" +}