1280 lines
36 KiB
TypeScript
1280 lines
36 KiB
TypeScript
import { Injectable, signal, computed, OnDestroy } from '@angular/core';
|
|
import { HttpClient } from '@angular/common/http';
|
|
import { Note, VaultNode, GraphData, TagInfo, VaultFolder, FileMetadata } from '../types';
|
|
import { VaultEventsService, VaultEventPayload } from './vault-events.service';
|
|
import { Subscription, firstValueFrom } from 'rxjs';
|
|
import { rewriteTagsFrontmatter } from '../app/shared/markdown/markdown-frontmatter.util';
|
|
|
|
// ============================================================================
|
|
// INTERFACES
|
|
// ============================================================================
|
|
|
|
interface VaultApiNote {
|
|
id: string;
|
|
title: string;
|
|
content: string;
|
|
tags: string[];
|
|
mtime: number;
|
|
fileName?: string;
|
|
filePath?: string;
|
|
originalPath?: string;
|
|
createdAt?: string;
|
|
updatedAt?: string;
|
|
}
|
|
|
|
interface VaultApiResponse {
|
|
notes: VaultApiNote[];
|
|
}
|
|
|
|
interface QuickLinkCounts {
|
|
all: number;
|
|
favorites: number;
|
|
templates: number;
|
|
tasks: number;
|
|
drafts: number;
|
|
archive: number;
|
|
trash: number;
|
|
}
|
|
|
|
// ============================================================================
|
|
// CONSTANTS
|
|
// ============================================================================
|
|
|
|
const TRASH_FOLDER = '.trash';
|
|
const REFRESH_DEBOUNCE_MS = 300;
|
|
const VAULT_API_ENDPOINT = '/api/vault';
|
|
const FILES_METADATA_ENDPOINT = '/api/files/metadata';
|
|
|
|
// Tag validation patterns
|
|
const TAG_VALIDATION = {
|
|
INVALID_CHARS: /[{}]/,
|
|
NUMERIC_ONLY: /^\d+$/,
|
|
HEX_LIKE: /^[0-9a-fA-F]{3,}$/,
|
|
INLINE_TAG: /(^|\s)#([A-Za-z0-9_\-\/]+)\b/g,
|
|
CODE_FENCE: /^```/
|
|
};
|
|
|
|
// ============================================================================
|
|
// SERVICE
|
|
// ============================================================================
|
|
|
|
@Injectable({
|
|
providedIn: 'root'
|
|
})
|
|
export class VaultService implements OnDestroy {
|
|
// ========================================
|
|
// STATE SIGNALS
|
|
// ========================================
|
|
|
|
private notesMap = signal<Map<string, Note>>(new Map());
|
|
private fastTreeSignal = signal<VaultNode[]>([]);
|
|
private openFolderPaths = signal(new Set<string>());
|
|
private vaultNameSignal = signal<string>(this.resolveInitialVaultName());
|
|
|
|
// Fast lookup indices for metadata
|
|
private idToPathIndex = new Map<string, string>();
|
|
private slugIdToPathIndex = new Map<string, string>();
|
|
private metaByPathIndex = new Map<string, FileMetadata>();
|
|
|
|
// Subscription management
|
|
private vaultEventsSubscription: Subscription | null = null;
|
|
private refreshTimeoutId: ReturnType<typeof setTimeout> | null = null;
|
|
|
|
// ========================================
|
|
// COMPUTED SIGNALS
|
|
// ========================================
|
|
|
|
readonly allNotes = computed(() => Array.from(this.notesMap().values()));
|
|
|
|
readonly trashNotes = computed<Note[]>(() =>
|
|
this.allNotes().filter(note => this.isInTrash(note.filePath || note.originalPath || ''))
|
|
);
|
|
|
|
readonly counts = computed<QuickLinkCounts>(() =>
|
|
this.calculateQuickLinkCounts()
|
|
);
|
|
|
|
readonly folderCounts = computed<Record<string, number>>(() =>
|
|
this.calculateFolderCounts()
|
|
);
|
|
|
|
readonly trashFolderCounts = computed<Record<string, number>>(() =>
|
|
this.calculateTrashFolderCounts()
|
|
);
|
|
|
|
readonly vaultName = computed(() => this.vaultNameSignal());
|
|
|
|
readonly fastFileTree = computed<VaultNode[]>(() => this.fastTreeSignal());
|
|
|
|
readonly fileTree = computed<VaultNode[]>(() =>
|
|
this.buildFileTree()
|
|
);
|
|
|
|
readonly trashTree = computed<VaultNode[]>(() =>
|
|
this.buildTrashTree()
|
|
);
|
|
|
|
readonly graphData = computed<GraphData>(() =>
|
|
this.buildGraphData()
|
|
);
|
|
|
|
readonly tags = computed<TagInfo[]>(() =>
|
|
this.extractTags()
|
|
);
|
|
|
|
// ========================================
|
|
// CONSTRUCTOR & LIFECYCLE
|
|
// ========================================
|
|
|
|
constructor(
|
|
private http: HttpClient,
|
|
private vaultEvents: VaultEventsService
|
|
) {
|
|
this.initialize();
|
|
}
|
|
|
|
ngOnDestroy(): void {
|
|
this.cleanup();
|
|
}
|
|
|
|
// ========================================
|
|
// INITIALIZATION
|
|
// ========================================
|
|
|
|
private initialize(): void {
|
|
this.loadFastFileTree();
|
|
this.refreshNotes();
|
|
this.observeVaultEvents();
|
|
}
|
|
|
|
private cleanup(): void {
|
|
this.vaultEventsSubscription?.unsubscribe();
|
|
this.vaultEventsSubscription = null;
|
|
|
|
if (this.refreshTimeoutId !== null) {
|
|
clearTimeout(this.refreshTimeoutId);
|
|
this.refreshTimeoutId = null;
|
|
}
|
|
}
|
|
|
|
// ========================================
|
|
// PUBLIC API
|
|
// ========================================
|
|
|
|
getNoteById(id: string): Note | undefined {
|
|
return this.notesMap().get(id);
|
|
}
|
|
|
|
async ensureNoteLoadedById(id: string): Promise<boolean> {
|
|
if (!id || this.getNoteById(id)) return !!id;
|
|
|
|
const path = this.idToPathIndex.get(id) || this.slugIdToPathIndex.get(id);
|
|
return path ? this.ensureNoteLoadedByPath(path) : false;
|
|
}
|
|
|
|
async ensureNoteLoadedByPath(path: string): Promise<boolean> {
|
|
if (!path) return false;
|
|
|
|
const slugId = this.buildSlugIdFromPath(path);
|
|
if (this.getNoteById(slugId)) return true;
|
|
|
|
try {
|
|
const rawContent = await this.fetchNoteContent(path);
|
|
const note = this.parseNoteFromContent(rawContent, slugId, path);
|
|
|
|
this.addNoteToMap(note);
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
toggleFolder(path: string): void {
|
|
this.openFolderPaths.update(paths => {
|
|
const updated = new Set(paths);
|
|
updated.has(path) ? updated.delete(path) : updated.add(path);
|
|
return updated;
|
|
});
|
|
this.applyOpenStateToFastTree();
|
|
}
|
|
|
|
ensureFolderOpen(originalPath: string): void {
|
|
if (!originalPath) return;
|
|
|
|
const parts = originalPath.split('/').filter(Boolean);
|
|
if (parts.length <= 1) return;
|
|
|
|
const updatedPaths = new Set(this.openFolderPaths());
|
|
let currentPath = '';
|
|
|
|
for (let i = 0; i < parts.length - 1; i++) {
|
|
currentPath = currentPath ? `${currentPath}/${parts[i]}` : parts[i];
|
|
updatedPaths.add(currentPath);
|
|
}
|
|
|
|
this.openFolderPaths.set(updatedPaths);
|
|
this.applyOpenStateToFastTree();
|
|
}
|
|
|
|
refresh(): void {
|
|
this.refreshNotes();
|
|
}
|
|
|
|
getFastMetaById(id: string): FileMetadata | undefined {
|
|
const path = this.idToPathIndex.get(id) || this.slugIdToPathIndex.get(id);
|
|
return path ? this.metaByPathIndex.get(path) : undefined;
|
|
}
|
|
|
|
async updateNoteTags(noteId: string, tags: string[]): Promise<boolean> {
|
|
const note = this.getNoteById(noteId);
|
|
if (!note?.filePath) return false;
|
|
|
|
const currentRaw = note.rawContent ?? this.recomposeMarkdownFromNote(note);
|
|
const updatedRaw = rewriteTagsFrontmatter(currentRaw, tags);
|
|
|
|
if (!await this.saveMarkdown(note.filePath, updatedRaw)) return false;
|
|
|
|
this.updateNoteInMap(note, { rawContent: updatedRaw, tags: this.normalizeTags(tags) });
|
|
return true;
|
|
}
|
|
|
|
// ========================================
|
|
// FAST FILE TREE
|
|
// ========================================
|
|
|
|
private loadFastFileTree(): void {
|
|
this.http.get<FileMetadata[]>(FILES_METADATA_ENDPOINT).subscribe({
|
|
next: (items) => {
|
|
try {
|
|
this.buildFastTree(items || []);
|
|
} catch (e) {
|
|
console.warn('[VaultService] Failed to build fast tree:', e);
|
|
}
|
|
},
|
|
error: () => {
|
|
// Silent fallback to regular tree
|
|
}
|
|
});
|
|
}
|
|
|
|
private buildFastTree(items: FileMetadata[]): void {
|
|
this.clearFastIndices();
|
|
|
|
const root = this.createRootFolder();
|
|
const folders = new Map<string, VaultFolder>([['', root]]);
|
|
|
|
for (const item of items) {
|
|
if (!item?.path) continue;
|
|
|
|
const path = this.normalizePath(item.path);
|
|
this.indexMetadata(item, path);
|
|
|
|
const parentFolder = this.buildFolderStructure(path, folders, root);
|
|
if (parentFolder) {
|
|
this.addFileNode(parentFolder, path, this.buildSlugIdFromPath(path));
|
|
}
|
|
}
|
|
|
|
this.sortFolderChildren(root);
|
|
this.fastTreeSignal.set(root.children);
|
|
}
|
|
|
|
private clearFastIndices(): void {
|
|
this.idToPathIndex.clear();
|
|
this.slugIdToPathIndex.clear();
|
|
this.metaByPathIndex.clear();
|
|
}
|
|
|
|
private indexMetadata(item: FileMetadata, path: string): void {
|
|
const slugId = this.buildSlugIdFromPath(path);
|
|
|
|
if (item.id) this.idToPathIndex.set(String(item.id), path);
|
|
if (slugId) this.slugIdToPathIndex.set(slugId, path);
|
|
this.metaByPathIndex.set(path, item);
|
|
}
|
|
|
|
private buildFolderStructure(
|
|
path: string,
|
|
folders: Map<string, VaultFolder>,
|
|
root: VaultFolder
|
|
): VaultFolder | null {
|
|
const parts = path.split('/').filter(Boolean);
|
|
const folderSegments = parts.slice(0, -1);
|
|
|
|
let currentPath = '';
|
|
let parentFolder: VaultFolder | null = root;
|
|
|
|
for (const segment of folderSegments) {
|
|
if (segment === TRASH_FOLDER) return null;
|
|
|
|
currentPath = currentPath ? `${currentPath}/${segment}` : segment;
|
|
|
|
let folder = folders.get(currentPath);
|
|
if (!folder) {
|
|
folder = this.createFolder(segment, currentPath);
|
|
folders.set(currentPath, folder);
|
|
parentFolder.children.push(folder);
|
|
} else {
|
|
folder.isOpen = this.openFolderPaths().has(currentPath);
|
|
}
|
|
|
|
parentFolder = folder;
|
|
}
|
|
|
|
return parentFolder;
|
|
}
|
|
|
|
private applyOpenStateToFastTree(): void {
|
|
const applyToNodes = (nodes: VaultNode[]) => {
|
|
for (const node of nodes) {
|
|
if (node.type === 'folder') {
|
|
node.isOpen = this.openFolderPaths().has(node.path);
|
|
applyToNodes(node.children);
|
|
}
|
|
}
|
|
};
|
|
|
|
const current = this.fastTreeSignal();
|
|
if (current.length === 0) return;
|
|
|
|
applyToNodes(current);
|
|
this.fastTreeSignal.set([...current]); // Trigger change detection
|
|
}
|
|
|
|
// ========================================
|
|
// FILE TREE BUILDERS
|
|
// ========================================
|
|
|
|
private buildFileTree(): VaultNode[] {
|
|
const root = this.createRootFolder();
|
|
const folders = new Map<string, VaultFolder>([['', root]]);
|
|
const openFolders = this.openFolderPaths();
|
|
|
|
const sortedNotes = this.getSortedNotes();
|
|
|
|
for (const note of sortedNotes) {
|
|
const segments = note.originalPath.split('/').filter(Boolean);
|
|
const folderSegments = segments.slice(0, -1);
|
|
|
|
const parentFolder = this.ensureFolderPath(folderSegments, folders, root, openFolders);
|
|
this.addFileNode(parentFolder, note.filePath, note.id, note.fileName);
|
|
}
|
|
|
|
this.sortAndCleanFolderChildren(root);
|
|
return root.children;
|
|
}
|
|
|
|
private buildTrashTree(): VaultNode[] {
|
|
const root = this.createFolder(TRASH_FOLDER, TRASH_FOLDER, true);
|
|
const folders = new Map<string, VaultFolder>([[TRASH_FOLDER, root]]);
|
|
const openFolders = this.openFolderPaths();
|
|
|
|
for (const note of this.allNotes()) {
|
|
const filePath = this.normalizePath(note.filePath || note.originalPath || '');
|
|
if (!this.isInTrash(filePath)) continue;
|
|
|
|
const segments = this.parseTrashFolderSegments(filePath);
|
|
const parentFolder = segments
|
|
? this.ensureTrashFolderPath(segments, folders, root, openFolders)
|
|
: root;
|
|
|
|
this.addFileNode(parentFolder, note.filePath, note.id, note.fileName);
|
|
}
|
|
|
|
this.sortAndCleanFolderChildren(root);
|
|
return root.children;
|
|
}
|
|
|
|
private ensureFolderPath(
|
|
segments: string[],
|
|
folders: Map<string, VaultFolder>,
|
|
root: VaultFolder,
|
|
openFolders: Set<string>
|
|
): VaultFolder {
|
|
let currentPath = '';
|
|
let parentFolder = root;
|
|
|
|
for (const segment of segments) {
|
|
currentPath = currentPath ? `${currentPath}/${segment}` : segment;
|
|
|
|
let folder = folders.get(currentPath);
|
|
if (!folder) {
|
|
folder = this.createFolder(segment, currentPath, openFolders.has(currentPath));
|
|
folders.set(currentPath, folder);
|
|
parentFolder.children.push(folder);
|
|
} else {
|
|
folder.isOpen = openFolders.has(currentPath);
|
|
}
|
|
|
|
parentFolder = folder;
|
|
}
|
|
|
|
return parentFolder;
|
|
}
|
|
|
|
private ensureTrashFolderPath(
|
|
segments: string[],
|
|
folders: Map<string, VaultFolder>,
|
|
root: VaultFolder,
|
|
openFolders: Set<string>
|
|
): VaultFolder {
|
|
let currentPath = TRASH_FOLDER;
|
|
let parentFolder = root;
|
|
|
|
for (const segment of segments) {
|
|
if (!segment) continue;
|
|
|
|
currentPath = `${currentPath}/${segment}`;
|
|
|
|
let folder = folders.get(currentPath);
|
|
if (!folder) {
|
|
folder = this.createFolder(segment, currentPath, openFolders.has(currentPath));
|
|
folders.set(currentPath, folder);
|
|
parentFolder.children.push(folder);
|
|
} else {
|
|
folder.isOpen = openFolders.has(currentPath);
|
|
}
|
|
|
|
parentFolder = folder;
|
|
}
|
|
|
|
return parentFolder;
|
|
}
|
|
|
|
// ========================================
|
|
// COUNTS CALCULATION
|
|
// ========================================
|
|
|
|
private calculateQuickLinkCounts(): QuickLinkCounts {
|
|
const counts: QuickLinkCounts = {
|
|
all: 0,
|
|
favorites: 0,
|
|
templates: 0,
|
|
tasks: 0,
|
|
drafts: 0,
|
|
archive: 0,
|
|
trash: 0
|
|
};
|
|
|
|
for (const note of this.allNotes()) {
|
|
const path = note.filePath || note.originalPath || '';
|
|
|
|
if (this.isInTrash(path)) {
|
|
counts.trash++;
|
|
continue;
|
|
}
|
|
|
|
counts.all++;
|
|
const fm = note.frontmatter || {};
|
|
|
|
if (fm.favoris === true) counts.favorites++;
|
|
if (fm.template === true) counts.templates++;
|
|
if (fm.task === true) counts.tasks++;
|
|
if (fm.draft === true) counts.drafts++;
|
|
if (fm.archive === true) counts.archive++;
|
|
}
|
|
|
|
return counts;
|
|
}
|
|
|
|
private calculateFolderCounts(): Record<string, number> {
|
|
const counts: Record<string, number> = {};
|
|
|
|
for (const note of this.allNotes()) {
|
|
const path = this.normalizePath(note.originalPath || note.filePath || '');
|
|
if (!path || this.isInTrash(path)) continue;
|
|
|
|
const parts = path.split('/');
|
|
parts.pop(); // Remove filename
|
|
|
|
let acc = '';
|
|
for (const segment of parts) {
|
|
if (!segment) continue;
|
|
acc = acc ? `${acc}/${segment}` : segment;
|
|
counts[acc] = (counts[acc] ?? 0) + 1;
|
|
}
|
|
}
|
|
|
|
return counts;
|
|
}
|
|
|
|
private calculateTrashFolderCounts(): Record<string, number> {
|
|
const counts: Record<string, number> = {};
|
|
|
|
const increment = (path: string) => {
|
|
const raw = this.normalizePath(path);
|
|
const norm = raw.replace(/^\/+|\/+$/g, '').toLowerCase();
|
|
counts[norm] = (counts[norm] ?? 0) + 1;
|
|
};
|
|
|
|
for (const note of this.allNotes()) {
|
|
const filePath = this.normalizePath(note.filePath || note.originalPath || '');
|
|
if (!this.isInTrash(filePath)) continue;
|
|
|
|
const segments = this.parseTrashFolderSegments(filePath);
|
|
|
|
// Always count the root .trash bucket
|
|
increment(TRASH_FOLDER);
|
|
|
|
if (!segments || segments.length === 0) {
|
|
continue;
|
|
}
|
|
|
|
let current = TRASH_FOLDER;
|
|
for (const segment of segments) {
|
|
current = `${current}/${segment}`;
|
|
increment(current);
|
|
}
|
|
}
|
|
|
|
return counts;
|
|
}
|
|
|
|
// ========================================
|
|
// GRAPH DATA
|
|
// ========================================
|
|
|
|
private buildGraphData(): GraphData {
|
|
const startTime = performance.now();
|
|
const notes = this.allNotes();
|
|
|
|
const nodes = notes.map(note => ({ id: note.id, label: note.title }));
|
|
const edges: { source: string; target: string }[] = [];
|
|
|
|
// Build fast lookup indices
|
|
const noteById = new Map(notes.map(n => [n.id, n]));
|
|
const noteByTitle = new Map(notes.map(n => [n.title, n]));
|
|
const notesByAlias = this.buildAliasIndex(notes);
|
|
|
|
// Extract links efficiently
|
|
for (const note of notes) {
|
|
const matches = note.content.matchAll(/\[\[([^|\]\n]+)(?:\|([^\]\n]+))?\]\]/g);
|
|
|
|
for (const match of matches) {
|
|
const rawLink = match[1];
|
|
const linkPath = rawLink.toLowerCase().replace(/\s+/g, '-');
|
|
|
|
const targetNote = noteById.get(linkPath)
|
|
|| noteByTitle.get(rawLink)
|
|
|| notesByAlias.get(rawLink);
|
|
|
|
if (targetNote && targetNote.id !== note.id) {
|
|
edges.push({ source: note.id, target: targetNote.id });
|
|
}
|
|
}
|
|
}
|
|
|
|
const duration = performance.now() - startTime;
|
|
console.log(`[GraphData] Computed in ${duration.toFixed(2)}ms: ${nodes.length} nodes, ${edges.length} edges`);
|
|
|
|
return { nodes, edges };
|
|
}
|
|
|
|
private buildAliasIndex(notes: Note[]): Map<string, Note> {
|
|
const index = new Map<string, Note>();
|
|
|
|
for (const note of notes) {
|
|
const aliases = note.frontmatter?.aliases;
|
|
if (Array.isArray(aliases)) {
|
|
for (const alias of aliases as string[]) {
|
|
index.set(alias, note);
|
|
}
|
|
}
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
// ========================================
|
|
// TAGS EXTRACTION
|
|
// ========================================
|
|
|
|
private extractTags(): TagInfo[] {
|
|
const tagCounts = new Map<string, number>();
|
|
|
|
for (const note of this.allNotes()) {
|
|
for (const tag of note.tags) {
|
|
if (this.isValidTag(tag)) {
|
|
tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
return Array.from(tagCounts.entries())
|
|
.map(([name, count]) => ({ name, count }))
|
|
.sort((a, b) => b.count - a.count);
|
|
}
|
|
|
|
private isValidTag(raw: string): boolean {
|
|
if (!raw) return false;
|
|
|
|
const tag = String(raw).trim();
|
|
if (!tag) return false;
|
|
if (TAG_VALIDATION.INVALID_CHARS.test(tag)) return false;
|
|
if (TAG_VALIDATION.NUMERIC_ONLY.test(tag)) return false;
|
|
if (TAG_VALIDATION.HEX_LIKE.test(tag)) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
// ========================================
|
|
// VAULT EVENTS
|
|
// ========================================
|
|
|
|
private observeVaultEvents(): void {
|
|
this.vaultEventsSubscription = this.vaultEvents.events$().subscribe({
|
|
next: (event) => this.handleVaultEvent(event),
|
|
error: (error) => console.error('Vault events stream error:', error)
|
|
});
|
|
}
|
|
|
|
private handleVaultEvent(event: VaultEventPayload): void {
|
|
if (!event?.event) return;
|
|
|
|
const refreshEvents = ['add', 'change', 'unlink', 'addDir', 'unlinkDir', 'ready', 'connected'];
|
|
|
|
if (refreshEvents.includes(event.event)) {
|
|
this.scheduleRefresh();
|
|
} else if (event.event === 'error') {
|
|
console.error('Vault watcher error:', event.message ?? 'Unknown error');
|
|
}
|
|
}
|
|
|
|
private scheduleRefresh(): void {
|
|
if (this.refreshTimeoutId !== null) {
|
|
clearTimeout(this.refreshTimeoutId);
|
|
}
|
|
|
|
this.refreshTimeoutId = setTimeout(() => {
|
|
this.refreshTimeoutId = null;
|
|
this.refreshNotes();
|
|
}, REFRESH_DEBOUNCE_MS);
|
|
}
|
|
|
|
// ========================================
|
|
// NOTES REFRESH
|
|
// ========================================
|
|
|
|
private refreshNotes(): void {
|
|
this.http.get<VaultApiResponse>(VAULT_API_ENDPOINT).subscribe({
|
|
next: ({ notes }) => this.processApiNotes(notes),
|
|
error: (error) => {
|
|
console.error('Failed to load vault notes from API', error);
|
|
this.notesMap.set(new Map());
|
|
}
|
|
});
|
|
}
|
|
|
|
private processApiNotes(apiNotes: VaultApiNote[]): void {
|
|
const newNotesMap = new Map<string, Note>();
|
|
let detectedVaultName: string | null = null;
|
|
|
|
for (const apiNote of apiNotes) {
|
|
const note = this.convertApiNoteToNote(apiNote);
|
|
newNotesMap.set(note.id, note);
|
|
|
|
const vaultName = this.extractVaultName(note);
|
|
if (vaultName) detectedVaultName = vaultName;
|
|
}
|
|
|
|
this.computeBacklinks(newNotesMap);
|
|
this.notesMap.set(newNotesMap);
|
|
|
|
if (detectedVaultName) {
|
|
this.vaultNameSignal.set(this.formatVaultName(detectedVaultName));
|
|
}
|
|
}
|
|
|
|
private convertApiNoteToNote(apiNote: VaultApiNote): Note {
|
|
const normalizedContent = this.normalizeLineEndings(apiNote.content);
|
|
const { frontmatter, body } = this.parseFrontmatter(normalizedContent);
|
|
|
|
const derivedTitle = this.extractTitle(body, apiNote.id);
|
|
const title = frontmatter.title || apiNote.title || derivedTitle;
|
|
|
|
const originalPath = this.normalizePath(
|
|
apiNote.originalPath ?? apiNote.filePath?.replace(/\.md$/i, '') ?? apiNote.id
|
|
);
|
|
|
|
const fileName = apiNote.fileName ?? this.deriveFileName(originalPath, apiNote);
|
|
const filePath = apiNote.filePath ?? `${originalPath}.md`;
|
|
|
|
const tags = this.extractAllTags(apiNote, frontmatter, body);
|
|
const updatedAt = apiNote.updatedAt || new Date(frontmatter.mtime || apiNote.mtime || Date.now()).toISOString();
|
|
|
|
return {
|
|
id: apiNote.id,
|
|
title,
|
|
content: body,
|
|
rawContent: normalizedContent,
|
|
tags: Array.from(tags),
|
|
frontmatter,
|
|
backlinks: [],
|
|
mtime: frontmatter.mtime || apiNote.mtime || Date.now(),
|
|
fileName,
|
|
filePath,
|
|
originalPath,
|
|
createdAt: apiNote.createdAt,
|
|
updatedAt
|
|
};
|
|
}
|
|
|
|
private extractAllTags(apiNote: VaultApiNote, frontmatter: any, body: string): Set<string> {
|
|
const tags = new Set<string>();
|
|
|
|
// API tags
|
|
if (Array.isArray(apiNote.tags)) {
|
|
apiNote.tags.forEach(tag => tags.add(tag));
|
|
}
|
|
|
|
// Frontmatter tags
|
|
if (Array.isArray(frontmatter.tags)) {
|
|
(frontmatter.tags as string[]).forEach(tag => tags.add(tag));
|
|
}
|
|
|
|
// Inline hashtags
|
|
this.extractInlineTags(body).forEach(tag => tags.add(tag));
|
|
|
|
return tags;
|
|
}
|
|
|
|
private extractInlineTags(body: string): Set<string> {
|
|
const tags = new Set<string>();
|
|
const lines = (body || '').split('\n');
|
|
let inCodeBlock = false;
|
|
|
|
for (const line of lines) {
|
|
const trimmed = line.trim();
|
|
|
|
if (TAG_VALIDATION.CODE_FENCE.test(trimmed)) {
|
|
inCodeBlock = !inCodeBlock;
|
|
continue;
|
|
}
|
|
|
|
if (inCodeBlock) continue;
|
|
|
|
const matches = line.matchAll(TAG_VALIDATION.INLINE_TAG);
|
|
for (const match of matches) {
|
|
tags.add(match[2]);
|
|
}
|
|
}
|
|
|
|
return tags;
|
|
}
|
|
|
|
private deriveFileName(originalPath: string, apiNote: VaultApiNote): string {
|
|
const parts = originalPath.split('/').filter(Boolean);
|
|
const lastSegment = parts.pop();
|
|
|
|
if (apiNote.filePath) {
|
|
return apiNote.filePath.split('/').pop() ?? `${lastSegment ?? apiNote.id}.md`;
|
|
}
|
|
|
|
return `${lastSegment ?? apiNote.id}.md`;
|
|
}
|
|
|
|
// ========================================
|
|
// BACKLINKS
|
|
// ========================================
|
|
|
|
private computeBacklinks(notesMap: Map<string, Note>): void {
|
|
const allNotes = Array.from(notesMap.values());
|
|
|
|
// Reset backlinks
|
|
allNotes.forEach(note => note.backlinks = []);
|
|
|
|
// Build lookup indices
|
|
const noteById = new Map(allNotes.map(n => [n.id, n]));
|
|
const noteByTitle = new Map(allNotes.map(n => [n.title, n]));
|
|
const notesByAlias = this.buildAliasIndex(allNotes);
|
|
|
|
for (const note of allNotes) {
|
|
const matches = note.content.matchAll(/\[\[([^|\]\n]+)(?:\|([^\]\n]+))?\]\]/g);
|
|
|
|
for (const match of matches) {
|
|
const rawLink = match[1];
|
|
const linkPath = rawLink.toLowerCase().replace(/\s+/g, '-');
|
|
|
|
const targetNote = noteById.get(linkPath)
|
|
|| noteByTitle.get(rawLink)
|
|
|| notesByAlias.get(rawLink);
|
|
|
|
if (targetNote && targetNote.id !== note.id) {
|
|
const target = notesMap.get(targetNote.id);
|
|
if (target && !target.backlinks.includes(note.id)) {
|
|
target.backlinks.push(note.id);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ========================================
|
|
// FRONTMATTER PARSING
|
|
// ========================================
|
|
|
|
private parseFrontmatter(content: string): { frontmatter: Record<string, any>; body: string } {
|
|
const sanitized = content.replace(/^\uFEFF/, '');
|
|
const normalized = this.normalizeLineEndings(sanitized);
|
|
|
|
const match = normalized.match(/^---\n([\s\S]+?)\n---\n?([\s\S]*)/);
|
|
if (!match) {
|
|
return { frontmatter: {}, body: content.trim() };
|
|
}
|
|
|
|
const [, frontmatterText, body] = match;
|
|
const frontmatter = this.parseFrontmatterLines(frontmatterText.split('\n'));
|
|
|
|
return { frontmatter, body: body.trim() };
|
|
}
|
|
|
|
private parseFrontmatterLines(lines: string[]): Record<string, any> {
|
|
const frontmatter: Record<string, any> = {};
|
|
|
|
for (let i = 0; i < lines.length; i++) {
|
|
const line = lines[i];
|
|
|
|
if (!line.trim() || line.trim().startsWith('#')) continue;
|
|
|
|
const colonIndex = line.indexOf(':');
|
|
if (colonIndex === -1) continue;
|
|
|
|
const key = line.slice(0, colonIndex).trim();
|
|
let valuePart = line.slice(colonIndex + 1).trim();
|
|
|
|
if (!key) continue;
|
|
|
|
// Handle list values
|
|
if (!valuePart) {
|
|
const { values, nextIndex } = this.parseListValues(lines, i + 1);
|
|
if (values.length) {
|
|
frontmatter[key] = values;
|
|
i = nextIndex - 1;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Handle array syntax [a, b, c]
|
|
if (valuePart.startsWith('[') && valuePart.endsWith(']')) {
|
|
const content = valuePart.slice(1, -1);
|
|
frontmatter[key] = content.split(',').map(v => this.parseFrontmatterValue(v.trim()));
|
|
continue;
|
|
}
|
|
|
|
frontmatter[key] = this.parseFrontmatterValue(valuePart);
|
|
}
|
|
|
|
return frontmatter;
|
|
}
|
|
|
|
private parseListValues(lines: string[], startIndex: number): { values: any[]; nextIndex: number } {
|
|
const values: any[] = [];
|
|
let j = startIndex;
|
|
|
|
while (j < lines.length) {
|
|
const line = lines[j];
|
|
|
|
if (!line.trim()) break;
|
|
|
|
if (/^\s*-\s+/.test(line)) {
|
|
const item = line.replace(/^\s*-\s+/, '').trim();
|
|
values.push(this.parseFrontmatterValue(item));
|
|
j++;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return { values, nextIndex: j };
|
|
}
|
|
|
|
private parseFrontmatterValue(rawValue: string): any {
|
|
const trimmed = rawValue.trim();
|
|
if (!trimmed) return '';
|
|
|
|
const unquoted = trimmed.replace(/^['"]|['"]$/g, '');
|
|
|
|
// Boolean
|
|
if (/^(true|false)$/i.test(unquoted)) {
|
|
return unquoted.toLowerCase() === 'true';
|
|
}
|
|
|
|
// Number
|
|
const numeric = Number(unquoted);
|
|
if (!isNaN(numeric) && unquoted !== '') {
|
|
return numeric;
|
|
}
|
|
|
|
return unquoted;
|
|
}
|
|
|
|
// ========================================
|
|
// HELPER FUNCTIONS
|
|
// ========================================
|
|
|
|
private extractTitle(content: string, fallback: string): string {
|
|
const match = content.match(/^#\s+(.*)/);
|
|
if (match) return match[1];
|
|
|
|
return fallback
|
|
.split('/')
|
|
.pop()!
|
|
.replace(/-/g, ' ')
|
|
.replace(/\b\w/g, l => l.toUpperCase());
|
|
}
|
|
|
|
private parseTrashFolderSegments(path: string): string[] | null {
|
|
if (!path) return null;
|
|
|
|
const parts = path.split('/').filter(Boolean);
|
|
let trashIndex = parts.indexOf(TRASH_FOLDER);
|
|
|
|
if (trashIndex === -1) {
|
|
const vaultIndex = parts.indexOf('vault');
|
|
if (vaultIndex !== -1 && parts[vaultIndex + 1] === TRASH_FOLDER) {
|
|
trashIndex = vaultIndex + 1;
|
|
}
|
|
}
|
|
|
|
if (trashIndex === -1) return null;
|
|
|
|
const afterTrash = parts.slice(trashIndex + 1);
|
|
if (afterTrash.length === 0) return null;
|
|
|
|
const result = afterTrash
|
|
.slice(0, -1)
|
|
.map(segment => {
|
|
try {
|
|
return decodeURIComponent(segment);
|
|
} catch {
|
|
return segment;
|
|
}
|
|
})
|
|
.map(s => s.trim())
|
|
.filter(Boolean);
|
|
|
|
console.log('🔍 [parseTrashFolderSegments]', {
|
|
input: path,
|
|
parts,
|
|
trashIndex,
|
|
afterTrash,
|
|
result
|
|
});
|
|
|
|
return result.length > 0 ? result : null;
|
|
}
|
|
|
|
buildSlugIdFromPath(filePath: string): string {
|
|
const noExt = filePath
|
|
.replace(/\\/g, '/')
|
|
.replace(/\.(md|excalidraw(?:\.md)?)$/i, '');
|
|
|
|
const segments = noExt.split('/').filter(Boolean);
|
|
const slugSegments = segments.map(seg => this.slugifySegment(seg));
|
|
|
|
return slugSegments.join('/');
|
|
}
|
|
|
|
private slugifySegment(segment: string): string {
|
|
const normalized = segment
|
|
.normalize('NFKD')
|
|
.replace(/[\u0300-\u036f]/g, '')
|
|
.trim();
|
|
|
|
const slug = normalized
|
|
.toLowerCase()
|
|
.replace(/[^a-z0-9]+/g, '-')
|
|
.replace(/^-+|-+$/g, '');
|
|
|
|
return slug || normalized.toLowerCase() || segment.toLowerCase();
|
|
}
|
|
|
|
private normalizePath(path: string): string {
|
|
return (path || '').replace(/\\/g, '/');
|
|
}
|
|
|
|
private normalizeLineEndings(content: string): string {
|
|
return content.replace(/\r\n/g, '\n');
|
|
}
|
|
|
|
private isInTrash(path: string): boolean {
|
|
const normalized = this.normalizePath(path).replace(/^\/+/, '');
|
|
return (
|
|
normalized.startsWith(`${TRASH_FOLDER}/`) ||
|
|
normalized.includes(`/${TRASH_FOLDER}/`)
|
|
);
|
|
}
|
|
|
|
private normalizeTags(tags: string[]): string[] {
|
|
return Array.from(new Set(
|
|
(tags || [])
|
|
.map(t => String(t).trim())
|
|
.filter(Boolean)
|
|
));
|
|
}
|
|
|
|
// ========================================
|
|
// VAULT NAME RESOLUTION
|
|
// ========================================
|
|
|
|
private resolveInitialVaultName(): string {
|
|
const homeFile = (window as any)?.APP_CONFIG?.vault?.home;
|
|
|
|
if (homeFile && typeof homeFile === 'string') {
|
|
const segments = homeFile.split(/[\/]/).filter(Boolean);
|
|
if (segments.length) {
|
|
return this.formatVaultName(segments[segments.length - 1]);
|
|
}
|
|
}
|
|
|
|
if (typeof window !== 'undefined') {
|
|
const appConfig = (window as any).APP_CONFIG;
|
|
const explicitName = appConfig?.vault?.name;
|
|
|
|
if (explicitName && typeof explicitName === 'string') {
|
|
return explicitName;
|
|
}
|
|
|
|
const configuredPath = appConfig?.vault?.path;
|
|
if (configuredPath && typeof configuredPath === 'string') {
|
|
const segments = configuredPath.split(/[\\/]/).filter(Boolean);
|
|
if (segments.length) {
|
|
return this.formatVaultName(segments[segments.length - 1]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return 'Vault';
|
|
}
|
|
|
|
private extractVaultName(note: Note): string | null {
|
|
const { frontmatter, filePath, originalPath } = note;
|
|
|
|
if (!this.shouldExtractVaultName(frontmatter, filePath, originalPath)) {
|
|
return null;
|
|
}
|
|
|
|
const candidateName = frontmatter.NomDeVoute
|
|
|| frontmatter.nomdevoute
|
|
|| frontmatter.vaultName;
|
|
|
|
return typeof candidateName === 'string' && candidateName.trim()
|
|
? candidateName.trim()
|
|
: null;
|
|
}
|
|
|
|
private shouldExtractVaultName(
|
|
frontmatter: Record<string, any>,
|
|
filePath?: string,
|
|
originalPath?: string
|
|
): boolean {
|
|
const hasVaultNameField = typeof frontmatter?.NomDeVoute === 'string'
|
|
|| typeof frontmatter?.nomdevoute === 'string'
|
|
|| typeof frontmatter?.vaultName === 'string';
|
|
|
|
if (!hasVaultNameField) return false;
|
|
|
|
const normalizedPath = this.normalizePath(filePath ?? originalPath ?? '');
|
|
const pathSegments = normalizedPath
|
|
.split('/')
|
|
.filter(Boolean)
|
|
.map(segment => segment.toLowerCase());
|
|
|
|
if (pathSegments.length === 0) return false;
|
|
|
|
const lastSegment = pathSegments[pathSegments.length - 1];
|
|
return pathSegments.length === 1 && (lastSegment === 'home.md' || lastSegment === 'home');
|
|
}
|
|
|
|
private formatVaultName(value: string): string {
|
|
return value
|
|
.replace(/[-_]+/g, ' ')
|
|
.replace(/\b\w/g, char => char.toUpperCase());
|
|
}
|
|
|
|
// ========================================
|
|
// FOLDER & NODE CREATION
|
|
// ========================================
|
|
|
|
private createRootFolder(): VaultFolder {
|
|
return {
|
|
type: 'folder',
|
|
name: 'root',
|
|
path: '',
|
|
children: [],
|
|
isOpen: true
|
|
};
|
|
}
|
|
|
|
private createFolder(name: string, path: string, isOpen: boolean = false): VaultFolder {
|
|
return {
|
|
type: 'folder',
|
|
name: name || '(unnamed)',
|
|
path,
|
|
children: [],
|
|
isOpen: isOpen || this.openFolderPaths().has(path)
|
|
};
|
|
}
|
|
|
|
private addFileNode(
|
|
folder: VaultFolder,
|
|
filePath: string,
|
|
id: string,
|
|
fileName?: string
|
|
): void {
|
|
const parts = filePath.split('/').filter(Boolean);
|
|
const name = fileName || parts[parts.length - 1] || filePath;
|
|
const normalizedPath = filePath.startsWith('/') ? filePath : `/${filePath}`;
|
|
|
|
folder.children.push({
|
|
type: 'file',
|
|
name,
|
|
path: normalizedPath,
|
|
id
|
|
});
|
|
}
|
|
|
|
// ========================================
|
|
// SORTING
|
|
// ========================================
|
|
|
|
private sortFolderChildren(folder: VaultFolder): void {
|
|
folder.children.sort((a, b) => {
|
|
if (a.type === 'folder' && b.type === 'file') return -1;
|
|
if (a.type === 'file' && b.type === 'folder') return 1;
|
|
return a.name.localeCompare(b.name, undefined, { sensitivity: 'base' });
|
|
});
|
|
|
|
for (const child of folder.children) {
|
|
if (child.type === 'folder') {
|
|
this.sortFolderChildren(child);
|
|
}
|
|
}
|
|
}
|
|
|
|
private sortAndCleanFolderChildren(folder: VaultFolder): void {
|
|
const cleanedChildren: VaultNode[] = [];
|
|
|
|
for (const child of folder.children) {
|
|
if (child.type === 'folder') {
|
|
// Skip trash folder
|
|
if (child.name === TRASH_FOLDER) continue;
|
|
|
|
this.sortAndCleanFolderChildren(child);
|
|
cleanedChildren.push(child);
|
|
} else {
|
|
cleanedChildren.push(child);
|
|
}
|
|
}
|
|
|
|
folder.children = cleanedChildren;
|
|
|
|
folder.children.sort((a, b) => {
|
|
if (a.type === 'folder' && b.type === 'file') return -1;
|
|
if (a.type === 'file' && b.type === 'folder') return 1;
|
|
return a.name.localeCompare(b.name, undefined, { sensitivity: 'base' });
|
|
});
|
|
}
|
|
|
|
private getSortedNotes(): Note[] {
|
|
return this.allNotes()
|
|
.slice()
|
|
.sort((a, b) =>
|
|
a.originalPath.localeCompare(b.originalPath, undefined, { sensitivity: 'base' })
|
|
);
|
|
}
|
|
|
|
// ========================================
|
|
// NOTE OPERATIONS
|
|
// ========================================
|
|
|
|
private async fetchNoteContent(path: string): Promise<string> {
|
|
const url = `/vault/${encodeURI(path)}`;
|
|
const raw = await firstValueFrom(
|
|
this.http.get(url, { responseType: 'text' as any })
|
|
);
|
|
return this.normalizeLineEndings(String(raw));
|
|
}
|
|
|
|
private parseNoteFromContent(rawContent: string, slugId: string, path: string): Note {
|
|
const { frontmatter, body } = this.parseFrontmatter(rawContent);
|
|
const derivedTitle = this.extractTitle(body, slugId);
|
|
const title = (frontmatter.title as string) || derivedTitle;
|
|
const meta = this.metaByPathIndex.get(path);
|
|
const fileName = path.split('/').pop() ?? `${slugId}.md`;
|
|
const updatedAt = meta?.updatedAt ?? new Date().toISOString();
|
|
|
|
return {
|
|
id: slugId,
|
|
title,
|
|
content: body,
|
|
rawContent,
|
|
tags: Array.isArray(frontmatter.tags) ? (frontmatter.tags as string[]) : [],
|
|
frontmatter,
|
|
backlinks: [],
|
|
mtime: Date.now(),
|
|
fileName,
|
|
filePath: path,
|
|
originalPath: path.replace(/\.md$/i, ''),
|
|
createdAt: meta?.createdAt,
|
|
updatedAt
|
|
};
|
|
}
|
|
|
|
private addNoteToMap(note: Note): void {
|
|
const current = new Map(this.notesMap());
|
|
current.set(note.id, note);
|
|
this.notesMap.set(current);
|
|
}
|
|
|
|
private updateNoteInMap(note: Note, updates: Partial<Note>): void {
|
|
const updated: Note = { ...note, ...updates };
|
|
const mapCopy = new Map(this.notesMap());
|
|
mapCopy.set(updated.id, updated);
|
|
this.notesMap.set(mapCopy);
|
|
}
|
|
|
|
// ========================================
|
|
// FILE OPERATIONS
|
|
// ========================================
|
|
|
|
private async saveMarkdown(filePath: string, content: string): Promise<boolean> {
|
|
try {
|
|
const url = `/api/files?path=${encodeURIComponent(filePath)}`;
|
|
await firstValueFrom(
|
|
this.http.put(url, content, {
|
|
headers: { 'Content-Type': 'text/markdown' }
|
|
})
|
|
);
|
|
return true;
|
|
} catch (e) {
|
|
console.error('[VaultService] saveMarkdown failed', e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private recomposeMarkdownFromNote(note: Note): string {
|
|
try {
|
|
const frontmatter = note.frontmatter || {};
|
|
const lines: string[] = ['---'];
|
|
|
|
for (const [key, value] of Object.entries(frontmatter)) {
|
|
if (key === 'tags') continue; // Handled by rewriteTagsFrontmatter
|
|
|
|
if (Array.isArray(value)) {
|
|
lines.push(`${key}:`);
|
|
for (const item of value) {
|
|
lines.push(` - ${item}`);
|
|
}
|
|
} else {
|
|
lines.push(`${key}: ${value}`);
|
|
}
|
|
}
|
|
|
|
lines.push('---', this.normalizeLineEndings(note.content ?? ''));
|
|
return lines.join('\n');
|
|
} catch {
|
|
return note.content ?? '';
|
|
}
|
|
}
|
|
} |