318 lines
8.8 KiB
JavaScript
318 lines
8.8 KiB
JavaScript
"use strict";
|
|
const utils = require("@electron-toolkit/utils");
|
|
const electron = require("electron");
|
|
const path = require("path");
|
|
const fs = require("fs/promises");
|
|
const matter = require("gray-matter");
|
|
const flexsearch = require("flexsearch");
|
|
const crypto = require("crypto");
|
|
class PluginRegistry {
|
|
constructor() {
|
|
this.plugins = /* @__PURE__ */ new Map();
|
|
}
|
|
register(plugin) {
|
|
if (!plugin.id) {
|
|
throw new Error("Plugin must have an id");
|
|
}
|
|
this.plugins.set(plugin.id, plugin);
|
|
}
|
|
get(id) {
|
|
return this.plugins.get(id);
|
|
}
|
|
list() {
|
|
return Array.from(this.plugins.values());
|
|
}
|
|
}
|
|
class BaseNotesAdapter {
|
|
constructor(config = {}) {
|
|
this.config = config;
|
|
}
|
|
async init() {
|
|
throw new Error("init() not implemented");
|
|
}
|
|
async getAll() {
|
|
throw new Error("getAll() not implemented");
|
|
}
|
|
async create(note) {
|
|
throw new Error("create() not implemented");
|
|
}
|
|
async update(note) {
|
|
throw new Error("update() not implemented");
|
|
}
|
|
async delete(id) {
|
|
throw new Error("delete() not implemented");
|
|
}
|
|
}
|
|
class FileSystemNotesAdapter extends BaseNotesAdapter {
|
|
constructor(config) {
|
|
super();
|
|
for (const field in config) {
|
|
this[field] = config[field];
|
|
}
|
|
}
|
|
async init() {
|
|
await fs.mkdir(this.notesDir, { recursive: true });
|
|
}
|
|
async getAll() {
|
|
const files = await fs.readdir(this.notesDir);
|
|
const notes = [];
|
|
for (const file of files) {
|
|
if (!file.endsWith(".md")) continue;
|
|
const fullPath = path.join(this.notesDir, file);
|
|
const raw = await fs.readFile(fullPath, "utf8");
|
|
const parsed = matter(raw);
|
|
notes.push({
|
|
...parsed.data,
|
|
content: parsed.content
|
|
});
|
|
}
|
|
return notes;
|
|
}
|
|
async create(note) {
|
|
await this._write(note);
|
|
}
|
|
async update(note) {
|
|
await this._write(note);
|
|
}
|
|
async delete(id) {
|
|
const filePath = path.join(this.notesDir, `${id}.md`);
|
|
await fs.unlink(filePath);
|
|
}
|
|
async _write(note) {
|
|
const filePath = path.join(this.notesDir, `${note.id}.md`);
|
|
const fileContent = matter.stringify(note.content, {
|
|
id: note.id,
|
|
title: note.title,
|
|
category: note.category ?? null,
|
|
createdAt: note.createdAt,
|
|
updatedAt: note.updatedAt
|
|
});
|
|
await fs.writeFile(filePath, fileContent, "utf8");
|
|
}
|
|
}
|
|
const filesystemPlugin = {
|
|
id: "filesystem",
|
|
name: "Local Filesystem",
|
|
description: "Stores notes as markdown files locally.",
|
|
version: "1.0.0",
|
|
configSchema: [
|
|
{
|
|
key: "notesDir",
|
|
label: "Notes Directory",
|
|
type: "directory",
|
|
default: path.join(electron.app.getPath("userData"), "notes"),
|
|
required: true
|
|
}
|
|
],
|
|
createAdapter(config) {
|
|
return new FileSystemNotesAdapter(config);
|
|
}
|
|
};
|
|
class PluginConfig {
|
|
constructor(defaultPlugin) {
|
|
this.defaultPlugin = defaultPlugin;
|
|
this.configPath = path.join(electron.app.getPath("userData"), "config.json");
|
|
}
|
|
async load() {
|
|
let parsed;
|
|
try {
|
|
const raw = await fs.readFile(this.configPath, "utf8");
|
|
parsed = JSON.parse(raw);
|
|
} catch (err) {
|
|
parsed = null;
|
|
}
|
|
if (!parsed || !parsed.activeAdapter) {
|
|
const defaultConfig = {};
|
|
for (const field of this.defaultPlugin.configSchema) {
|
|
defaultConfig[field.key] = field.default ?? null;
|
|
}
|
|
parsed = {
|
|
activeAdapter: this.defaultPlugin.id,
|
|
adapterConfig: defaultConfig
|
|
};
|
|
await this.write(parsed);
|
|
}
|
|
return parsed;
|
|
}
|
|
async write(configObject) {
|
|
const dir = path.dirname(this.configPath);
|
|
await fs.mkdir(dir, { recursive: true });
|
|
await fs.writeFile(
|
|
this.configPath,
|
|
JSON.stringify(configObject, null, 2),
|
|
"utf8"
|
|
);
|
|
}
|
|
}
|
|
class NotesAPI {
|
|
constructor(adapter) {
|
|
if (!adapter) {
|
|
throw new Error("NotesAPI requires a storage adapter");
|
|
}
|
|
this.adapter = adapter;
|
|
this.notesCache = /* @__PURE__ */ new Map();
|
|
this.index = new flexsearch.Index({
|
|
tokenize: "tolerant",
|
|
resolution: 9
|
|
});
|
|
}
|
|
async init() {
|
|
await this.adapter.init();
|
|
const notes = await this.adapter.getAll();
|
|
for (const note of notes) {
|
|
this.notesCache.set(note.id, note);
|
|
this.index.add(note.id, note.title + "\n" + note.content);
|
|
}
|
|
}
|
|
/* -----------------------
|
|
Public API
|
|
------------------------*/
|
|
getCategories() {
|
|
const categories = /* @__PURE__ */ new Set();
|
|
for (const note of this.notesCache.values()) {
|
|
if (note.category) {
|
|
categories.add(note.category);
|
|
}
|
|
}
|
|
return Array.from(categories).sort();
|
|
}
|
|
getCategoryNotes(categoryName) {
|
|
return Array.from(this.notesCache.values()).filter((n) => n.category === categoryName).sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
|
|
}
|
|
getNote(id) {
|
|
return this.notesCache.get(id) ?? null;
|
|
}
|
|
async createNote(metadata = {}, content = "") {
|
|
const id = crypto.randomUUID();
|
|
const now = (/* @__PURE__ */ new Date()).toISOString();
|
|
const note = {
|
|
id,
|
|
title: metadata.title || "Untitled",
|
|
category: metadata.category || null,
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
content
|
|
};
|
|
this.notesCache.set(id, note);
|
|
this.index.add(id, note.title + "\n" + content);
|
|
await this.adapter.create(note);
|
|
return note;
|
|
}
|
|
async deleteNote(id) {
|
|
await this.adapter.delete(id);
|
|
this.notesCache.delete(id);
|
|
this.index.remove(id);
|
|
}
|
|
async updateNote(id, content) {
|
|
const note = this.notesCache.get(id);
|
|
if (!note) throw new Error("Note not found");
|
|
note.content = content;
|
|
note.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
|
|
this.index.update(id, note.title + "\n" + content);
|
|
await this.adapter.update(note);
|
|
return note;
|
|
}
|
|
async updateNoteMetadata(id, updates = {}) {
|
|
const note = this.notesCache.get(id);
|
|
if (!note) throw new Error("Note not found");
|
|
const allowedFields = ["title", "category"];
|
|
for (const key of Object.keys(updates)) {
|
|
if (!allowedFields.includes(key)) {
|
|
throw new Error(`Invalid metadata field: ${key}`);
|
|
}
|
|
}
|
|
if (updates.title !== void 0) {
|
|
note.title = updates.title;
|
|
}
|
|
if (updates.category !== void 0) {
|
|
note.category = updates.category;
|
|
}
|
|
note.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
|
|
this.index.update(id, note.title + "\n" + note.content);
|
|
await this.adapter.update(note);
|
|
return note;
|
|
}
|
|
search(query) {
|
|
const ids = this.index.search(query);
|
|
return ids.map((id) => this.notesCache.get(id));
|
|
}
|
|
}
|
|
const preloadPath = path.join(__dirname, "../preload/index.js");
|
|
const rendererPath = path.join(__dirname, "../renderer/index.html");
|
|
function createWindow() {
|
|
const mainWindow2 = new electron.BrowserWindow({
|
|
width: 354,
|
|
height: 549,
|
|
show: false,
|
|
autoHideMenuBar: true,
|
|
webPreferences: {
|
|
preload: preloadPath,
|
|
sandbox: false
|
|
}
|
|
});
|
|
mainWindow2.on("ready-to-show", () => {
|
|
mainWindow2.show();
|
|
});
|
|
mainWindow2.webContents.setWindowOpenHandler((details) => {
|
|
electron.shell.openExternal(details.url);
|
|
return { action: "deny" };
|
|
});
|
|
if (utils.is.dev && process.env["ELECTRON_RENDERER_URL"]) {
|
|
mainWindow2.loadURL(process.env["ELECTRON_RENDERER_URL"]);
|
|
} else {
|
|
mainWindow2.loadFile(rendererPath);
|
|
}
|
|
}
|
|
function createNoteWindow(noteId) {
|
|
const noteWindow = new electron.BrowserWindow({
|
|
width: 354,
|
|
height: 549,
|
|
autoHideMenuBar: true,
|
|
webPreferences: {
|
|
preload: preloadPath,
|
|
contextIsolation: true,
|
|
nodeIntegration: false
|
|
}
|
|
});
|
|
if (utils.is.dev && process.env["ELECTRON_RENDERER_URL"]) {
|
|
noteWindow.loadURL(
|
|
`${process.env["ELECTRON_RENDERER_URL"]}/note/${noteId}`
|
|
);
|
|
} else {
|
|
mainWindow.loadFile(rendererPath, {
|
|
path: `/notes/${noteId}`
|
|
});
|
|
}
|
|
}
|
|
electron.app.whenReady().then(async () => {
|
|
utils.electronApp.setAppUserModelId("com.electron");
|
|
electron.app.on("browser-window-created", (_, window) => {
|
|
utils.optimizer.watchWindowShortcuts(window);
|
|
});
|
|
createWindow();
|
|
electron.app.on("activate", function() {
|
|
if (electron.BrowserWindow.getAllWindows().length === 0) createWindow();
|
|
});
|
|
electron.ipcMain.on("open-note-window", (_, noteId) => {
|
|
createNoteWindow(noteId);
|
|
});
|
|
const registry = new PluginRegistry();
|
|
registry.register(filesystemPlugin);
|
|
const config = await new PluginConfig(filesystemPlugin).load();
|
|
const plugin = registry.get(config.activeAdapter);
|
|
const adapter = plugin.createAdapter(config.adapterConfig);
|
|
const notesAPI = new NotesAPI(adapter);
|
|
await notesAPI.init();
|
|
electron.ipcMain.handle("notesAPI:call", (_, method, args) => {
|
|
if (!notesAPI[method]) {
|
|
throw new Error("Invalid method");
|
|
}
|
|
return notesAPI[method](...args);
|
|
});
|
|
});
|
|
electron.app.on("window-all-closed", () => {
|
|
if (process.platform !== "darwin") {
|
|
electron.app.quit();
|
|
}
|
|
});
|