v0.18.0

* basic implementation of file rename support

* tweaks to various tests

* make lint happy again

* Improved reporting

* added setting related to file sync

* added documentation in readme

lerna.json

@@ -4,5 +4,5 @@
   ],
   "npmClient": "yarn",
   "useWorkspaces": true,
-  "version": "0.17.6"
+  "version": "0.18.0"
 }

packages/foam-vscode/CHANGELOG.md

@@ -4,6 +4,27 @@ All notable changes to the "foam-vscode" extension will be documented in this fi
 
 Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how to structure this file.
 
+## [0.18.0] - 2022-04-11
+
+Features:
+- Link synchronization on file rename
+
+Internal:
+- Changed graph computation on workspace change to simplify code
+
+## [0.17.8] - 2022-04-01
+
+Fixes and Improvements:
+- Do not add ignored files to Foam upon change (#480)
+- Restore full use of editor.action.openLink (#693)
+- Minor performance improvements
+
+## [0.17.7] - 2022-03-29
+
+Fixes and Improvements:
+- Include links with sections in backlinks (#895)
+- Improved navigation when document editor is already open
+
 ## [0.17.6] - 2022-03-03
 
 Fixes and Improvements:

packages/foam-vscode/README.md

@@ -27,6 +27,12 @@ Foam helps you create the connections between your notes, and your placeholders
 
 ![Link Autocompletion](./assets/screenshots/feature-link-autocompletion.gif)
 
+### Sync links on file rename
+
+Foam updates the links to renamed files, so your notes stay consistent.
+
+![Sync links on file rename](./assets/screenshots/feature-link-sync.gif)
+
 ### Unique identifiers across directories
 
 Foam supports files with the same name in multiple directories.

packages/foam-vscode/package.json

@@ -8,7 +8,7 @@
     "type": "git"
   },
   "homepage": "https://github.com/foambubble/foam",
-  "version": "0.17.6",
+  "version": "0.18.0",
   "license": "MIT",
   "publisher": "foam",
   "engines": {
@@ -255,6 +255,11 @@
             "Disable wikilink definitions generation"
           ]
         },
+        "foam.links.sync.enable": {
+          "description": "Enable synching links when moving/renaming notes",
+          "type": "boolean",
+          "default": true
+        },
         "foam.links.hover.enable": {
           "description": "Enable displaying note content on hover links",
           "type": "boolean",
@@ -418,7 +423,8 @@
     "tsdx": "^0.13.2",
     "tslib": "^2.0.0",
     "typescript": "^3.9.5",
-    "vscode-test": "^1.3.0"
+    "vscode-test": "^1.3.0",
+    "wait-for-expect": "^3.0.2"
   },
   "dependencies": {
     "dateformat": "^3.0.3",

packages/foam-vscode/src/core/common/snippetParser.test.ts

@@ -442,7 +442,7 @@ describe('SnippetParser', () => {
 		assert.strictEqual(children[3].children.length, 0);
 		assert.notStrictEqual((<Placeholder>children[3]).transform, undefined);
 		let transform = (<Placeholder>children[3]).transform!;
-		assert.deepStrictEqual(transform.regexp, /\s:=(.*)/);
+		assert.deepStrictEqual(transform.regexp.source, /\s:=(.*)/.source);
 		assert.strictEqual(transform.children.length, 2);
 		assert.ok(transform.children[0] instanceof FormatString);
 		assert.strictEqual((<FormatString>transform.children[0]).index, 1);

packages/foam-vscode/src/core/janitor/generateHeadings.test.ts

@@ -1,6 +1,6 @@
 import { generateHeading } from '.';
 import { TEST_DATA_DIR } from '../../test/test-utils';
-import { MarkdownResourceProvider } from '../markdown-provider';
+import { MarkdownResourceProvider } from '../services/markdown-provider';
 import { bootstrap } from '../model/foam';
 import { Resource } from '../model/note';
 import { Range } from '../model/range';

packages/foam-vscode/src/core/janitor/generateLinkReferences.test.ts

@@ -1,6 +1,6 @@
 import { generateLinkReferences } from '.';
 import { TEST_DATA_DIR } from '../../test/test-utils';
-import { MarkdownResourceProvider } from '../markdown-provider';
+import { MarkdownResourceProvider } from '../services/markdown-provider';
 import { bootstrap } from '../model/foam';
 import { Resource } from '../model/note';
 import { Range } from '../model/range';

packages/foam-vscode/src/core/janitor/index.ts

@@ -3,7 +3,7 @@ import { Range } from '../model/range';
 import {
   createMarkdownReferences,
   stringifyMarkdownLinkReferenceDefinition,
-} from '../markdown-provider';
+} from '../services/markdown-provider';
 import { getHeadingFromFileName } from '../utils';
 import { FoamWorkspace } from '../model/workspace';
 

packages/foam-vscode/src/core/markdown-provider.test.ts

@@ -1,489 +0,0 @@
-import {
-  createMarkdownParser,
-  createMarkdownReferences,
-  ParserPlugin,
-} from './markdown-provider';
-import { DirectLink, WikiLink } from './model/note';
-import { Logger } from './utils/log';
-import { URI } from './model/uri';
-import { FoamGraph } from './model/graph';
-import { Range } from './model/range';
-import { createTestWorkspace, getRandomURI } from '../test/test-utils';
-
-Logger.setLevel('error');
-
-const pageA = `
-# Page A
-
-## Section
-- [[page-b]]
-- [[page-c]]
-- [[Page D]]
-- [[page e]]
-`;
-
-const pageB = `
-# Page B
-
-This references [[page-a]]`;
-
-const pageC = `
-# Page C
-`;
-
-const pageD = `
-# Page D
-`;
-
-const pageE = `
-# Page E
-`;
-
-const createNoteFromMarkdown = (content: string, path?: string) =>
-  createMarkdownParser([]).parse(
-    path ? URI.file(path) : getRandomURI(),
-    content
-  );
-
-describe('Markdown loader', () => {
-  it('Converts markdown to notes', () => {
-    const workspace = createTestWorkspace();
-    workspace.set(createNoteFromMarkdown(pageA, '/page-a.md'));
-    workspace.set(createNoteFromMarkdown(pageB, '/page-b.md'));
-    workspace.set(createNoteFromMarkdown(pageC, '/page-c.md'));
-    workspace.set(createNoteFromMarkdown(pageD, '/page-d.md'));
-    workspace.set(createNoteFromMarkdown(pageE, '/page-e.md'));
-
-    expect(
-      workspace
-        .list()
-        .map(n => n.uri.getName())
-        .sort()
-    ).toEqual(['page-a', 'page-b', 'page-c', 'page-d', 'page-e']);
-  });
-
-  it('Ignores external links', () => {
-    const note = createNoteFromMarkdown(
-      `this is a [link to google](https://www.google.com)`
-    );
-    expect(note.links.length).toEqual(0);
-  });
-
-  it('Ignores references to sections in the same file', () => {
-    const note = createNoteFromMarkdown(
-      `this is a [link to intro](#introduction)`
-    );
-    expect(note.links.length).toEqual(0);
-  });
-
-  it('Parses internal links correctly', () => {
-    const note = createNoteFromMarkdown(
-      'this is a [link to page b](../doc/page-b.md)'
-    );
-    expect(note.links.length).toEqual(1);
-    const link = note.links[0] as DirectLink;
-    expect(link.type).toEqual('link');
-    expect(link.label).toEqual('link to page b');
-    expect(link.target).toEqual('../doc/page-b.md');
-  });
-
-  it('Parses links that have formatting in label', () => {
-    const note = createNoteFromMarkdown(
-      'this is [**link** with __formatting__](../doc/page-b.md)'
-    );
-    expect(note.links.length).toEqual(1);
-    const link = note.links[0] as DirectLink;
-    expect(link.type).toEqual('link');
-    expect(link.label).toEqual('link with formatting');
-    expect(link.target).toEqual('../doc/page-b.md');
-  });
-
-  it('Parses wikilinks correctly', () => {
-    const workspace = createTestWorkspace();
-    const noteA = createNoteFromMarkdown(pageA, '/page-a.md');
-    const noteB = createNoteFromMarkdown(pageB, '/page-b.md');
-    const noteC = createNoteFromMarkdown(pageC, '/page-c.md');
-    const noteD = createNoteFromMarkdown(pageD, '/Page D.md');
-    const noteE = createNoteFromMarkdown(pageE, '/page e.md');
-
-    workspace
-      .set(noteA)
-      .set(noteB)
-      .set(noteC)
-      .set(noteD)
-      .set(noteE);
-    const graph = FoamGraph.fromWorkspace(workspace);
-
-    expect(graph.getBacklinks(noteB.uri).map(l => l.source)).toEqual([
-      noteA.uri,
-    ]);
-    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([
-      noteB.uri,
-      noteC.uri,
-      noteD.uri,
-      noteE.uri,
-    ]);
-  });
-
-  it('Parses backlinks with an alias', () => {
-    const note = createNoteFromMarkdown(
-      'this is [[link|link alias]]. A link with spaces [[other link | spaced]]'
-    );
-    expect(note.links.length).toEqual(2);
-    let link = note.links[0] as WikiLink;
-    expect(link.type).toEqual('wikilink');
-    expect(link.rawText).toEqual('[[link|link alias]]');
-    expect(link.label).toEqual('link alias');
-    expect(link.target).toEqual('link');
-    link = note.links[1] as WikiLink;
-    expect(link.type).toEqual('wikilink');
-    expect(link.rawText).toEqual('[[other link | spaced]]');
-    expect(link.label).toEqual('spaced');
-    expect(link.target).toEqual('other link');
-  });
-
-  it('Skips wikilinks in codeblocks', () => {
-    const noteA = createNoteFromMarkdown(`
-this is some text with our [[first-wikilink]].
-
-\`\`\`
-this is inside a [[codeblock]]
-\`\`\`
-
-this is some text with our [[second-wikilink]].
-    `);
-    expect(noteA.links.map(l => l.label)).toEqual([
-      'first-wikilink',
-      'second-wikilink',
-    ]);
-  });
-
-  it('Skips wikilinks in inlined codeblocks', () => {
-    const noteA = createNoteFromMarkdown(`
-this is some text with our [[first-wikilink]].
-
-this is \`inside a [[codeblock]]\`
-
-this is some text with our [[second-wikilink]].
-    `);
-    expect(noteA.links.map(l => l.label)).toEqual([
-      'first-wikilink',
-      'second-wikilink',
-    ]);
-  });
-});
-
-describe('Note Title', () => {
-  it('should initialize note title if heading exists', () => {
-    const note = createNoteFromMarkdown(`
-# Page A
-this note has a title
-    `);
-    expect(note.title).toBe('Page A');
-  });
-
-  it('should support wikilinks and urls in title', () => {
-    const note = createNoteFromMarkdown(`
-# Page A with [[wikilink]] and a [url](https://google.com)
-this note has a title
-    `);
-    expect(note.title).toBe('Page A with wikilink and a url');
-  });
-
-  it('should default to file name if heading does not exist', () => {
-    const note = createNoteFromMarkdown(
-      `This file has no heading.`,
-      '/page-d.md'
-    );
-
-    expect(note.title).toEqual('page-d');
-  });
-
-  it('should give precedence to frontmatter title over other headings', () => {
-    const note = createNoteFromMarkdown(`
----
-title: Note Title
-date: 20-12-12
----
-
-# Other Note Title
-    `);
-
-    expect(note.title).toBe('Note Title');
-  });
-
-  it('should support numbers', () => {
-    const note1 = createNoteFromMarkdown(`hello`, '/157.md');
-    expect(note1.title).toBe('157');
-
-    const note2 = createNoteFromMarkdown(`# 158`, '/157.md');
-    expect(note2.title).toBe('158');
-
-    const note3 = createNoteFromMarkdown(
-      `
----
-title: 159
----
-
-# 158
-`,
-      '/157.md'
-    );
-    expect(note3.title).toBe('159');
-  });
-
-  it('should not break on empty titles (see #276)', () => {
-    const note = createNoteFromMarkdown(
-      `
-#
-
-this note has an empty title line
-    `,
-      '/Hello Page.md'
-    );
-    expect(note.title).toEqual('Hello Page');
-  });
-});
-
-describe('frontmatter', () => {
-  it('should parse yaml frontmatter', () => {
-    const note = createNoteFromMarkdown(`
----
-title: Note Title
-date: 20-12-12
----
-
-# Other Note Title`);
-
-    expect(note.properties.title).toBe('Note Title');
-    expect(note.properties.date).toBe('20-12-12');
-  });
-
-  it('should parse empty frontmatter', () => {
-    const note = createNoteFromMarkdown(`
----
----
-
-# Empty Frontmatter
-`);
-
-    expect(note.properties).toEqual({});
-  });
-
-  it('should not fail when there are issues with parsing frontmatter', () => {
-    const note = createNoteFromMarkdown(`
----
-title: - one
- - two
- - #
----
-
-`);
-
-    expect(note.properties).toEqual({});
-  });
-});
-
-describe('wikilinks definitions', () => {
-  it('can generate links without file extension when includeExtension = false', () => {
-    const workspace = createTestWorkspace();
-    const noteA = createNoteFromMarkdown(pageA, '/dir1/page-a.md');
-    workspace
-      .set(noteA)
-      .set(createNoteFromMarkdown(pageB, '/dir1/page-b.md'))
-      .set(createNoteFromMarkdown(pageC, '/dir1/page-c.md'));
-
-    const noExtRefs = createMarkdownReferences(workspace, noteA.uri, false);
-    expect(noExtRefs.map(r => r.url)).toEqual(['page-b', 'page-c']);
-  });
-
-  it('can generate links with file extension when includeExtension = true', () => {
-    const workspace = createTestWorkspace();
-    const noteA = createNoteFromMarkdown(pageA, '/dir1/page-a.md');
-    workspace
-      .set(noteA)
-      .set(createNoteFromMarkdown(pageB, '/dir1/page-b.md'))
-      .set(createNoteFromMarkdown(pageC, '/dir1/page-c.md'));
-
-    const extRefs = createMarkdownReferences(workspace, noteA.uri, true);
-    expect(extRefs.map(r => r.url)).toEqual(['page-b.md', 'page-c.md']);
-  });
-
-  it('use relative paths', () => {
-    const workspace = createTestWorkspace();
-    const noteA = createNoteFromMarkdown(pageA, '/dir1/page-a.md');
-    workspace
-      .set(noteA)
-      .set(createNoteFromMarkdown(pageB, '/dir2/page-b.md'))
-      .set(createNoteFromMarkdown(pageC, '/dir3/page-c.md'));
-
-    const extRefs = createMarkdownReferences(workspace, noteA.uri, true);
-    expect(extRefs.map(r => r.url)).toEqual([
-      '../dir2/page-b.md',
-      '../dir3/page-c.md',
-    ]);
-  });
-});
-
-describe('tags plugin', () => {
-  it('can find tags in the text of the note', () => {
-    const noteA = createNoteFromMarkdown(`
-# this is a #heading
-#this is some #text that includes #tags we #care-about.
-    `);
-    expect(noteA.tags).toEqual([
-      { label: 'heading', range: Range.create(1, 12, 1, 20) },
-      { label: 'this', range: Range.create(2, 0, 2, 5) },
-      { label: 'text', range: Range.create(2, 14, 2, 19) },
-      { label: 'tags', range: Range.create(2, 34, 2, 39) },
-      { label: 'care-about', range: Range.create(2, 43, 2, 54) },
-    ]);
-  });
-
-  it('will skip tags in codeblocks', () => {
-    const noteA = createNoteFromMarkdown(`
-this is some #text that includes #tags we #care-about.
-
-\`\`\`
-this is a #codeblock
-\`\`\`
-    `);
-    expect(noteA.tags.map(t => t.label)).toEqual([
-      'text',
-      'tags',
-      'care-about',
-    ]);
-  });
-
-  it('will skip tags in inlined codeblocks', () => {
-    const noteA = createNoteFromMarkdown(`
-this is some #text that includes #tags we #care-about.
-this is a \`inlined #codeblock\` `);
-    expect(noteA.tags.map(t => t.label)).toEqual([
-      'text',
-      'tags',
-      'care-about',
-    ]);
-  });
-  it('can find tags as text in yaml', () => {
-    const noteA = createNoteFromMarkdown(`
----
-tags: hello, world  this_is_good
----
-# this is a heading
-this is some #text that includes #tags we #care-about.
-    `);
-    expect(noteA.tags.map(t => t.label)).toEqual([
-      'hello',
-      'world',
-      'this_is_good',
-      'text',
-      'tags',
-      'care-about',
-    ]);
-  });
-
-  it('can find tags as array in yaml', () => {
-    const noteA = createNoteFromMarkdown(`
----
-tags: [hello, world,  this_is_good]
----
-# this is a heading
-this is some #text that includes #tags we #care-about.
-    `);
-    expect(noteA.tags.map(t => t.label)).toEqual([
-      'hello',
-      'world',
-      'this_is_good',
-      'text',
-      'tags',
-      'care-about',
-    ]);
-  });
-
-  it('provides rough range for tags in yaml', () => {
-    // For now it's enough to just get the YAML block range
-    // in the future we might want to be more specific
-
-    const noteA = createNoteFromMarkdown(`
----
-tags: [hello, world, this_is_good]
----
-# this is a heading
-this is some text
-    `);
-    expect(noteA.tags[0]).toEqual({
-      label: 'hello',
-      range: Range.create(1, 0, 3, 3),
-    });
-  });
-});
-
-describe('Sections plugin', () => {
-  it('should find sections within the note', () => {
-    const note = createNoteFromMarkdown(`
-# Section 1
-
-This is the content of section 1.
-
-## Section 1.1
-
-This is the content of section 1.1.
-
-# Section 2
-
-This is the content of section 2.
-      `);
-    expect(note.sections).toHaveLength(3);
-    expect(note.sections[0].label).toEqual('Section 1');
-    expect(note.sections[0].range).toEqual(Range.create(1, 0, 9, 0));
-    expect(note.sections[1].label).toEqual('Section 1.1');
-    expect(note.sections[1].range).toEqual(Range.create(5, 0, 9, 0));
-    expect(note.sections[2].label).toEqual('Section 2');
-    expect(note.sections[2].range).toEqual(Range.create(9, 0, 13, 0));
-  });
-
-  it('should support wikilinks and links in the section label', () => {
-    const note = createNoteFromMarkdown(`
-# Section with [[wikilink]]
-
-This is the content of section with wikilink
-
-## Section with [url](https://google.com)
-
-This is the content of section with url`);
-    expect(note.sections).toHaveLength(2);
-    expect(note.sections[0].label).toEqual('Section with wikilink');
-    expect(note.sections[1].label).toEqual('Section with url');
-  });
-});
-
-describe('parser plugins', () => {
-  const testPlugin: ParserPlugin = {
-    visit: (node, note) => {
-      if (node.type === 'heading') {
-        note.properties.hasHeading = true;
-      }
-    },
-  };
-  const parser = createMarkdownParser([testPlugin]);
-
-  it('can augment the parsing of the file', () => {
-    const note1 = parser.parse(
-      URI.file('/path/to/a'),
-      `
-This is a test note without headings.
-But with some content.
-`
-    );
-    expect(note1.properties.hasHeading).toBeUndefined();
-
-    const note2 = parser.parse(
-      URI.file('/path/to/a'),
-      `
-# This is a note with header
-and some content`
-    );
-    expect(note2.properties.hasHeading).toBeTruthy();
-  });
-});

packages/foam-vscode/src/core/model/foam.ts

@@ -4,8 +4,9 @@ import { FoamWorkspace } from './workspace';
 import { FoamGraph } from './graph';
 import { ResourceParser } from './note';
 import { ResourceProvider } from './provider';
-import { createMarkdownParser } from '../markdown-provider';
+import { createMarkdownParser } from '../services/markdown-parser';
 import { FoamTags } from './tags';
+import { Logger } from '../utils/log';
 
 export interface Services {
   dataStore: IDataStore;
@@ -27,10 +28,19 @@ export const bootstrap = async (
 ) => {
   const parser = createMarkdownParser([]);
   const workspace = new FoamWorkspace();
-  await Promise.all(initialProviders.map(p => workspace.registerProvider(p)));
+  const tsStart = Date.now();
+
+  await Promise.all(initialProviders.map(p => workspace.registerProvider(p)));
+  const tsWsDone = Date.now();
+  Logger.info(`Workspace loaded in ${tsWsDone - tsStart}ms`);
+
+  const graph = FoamGraph.fromWorkspace(workspace, true, 500);
+  const tsGraphDone = Date.now();
+  Logger.info(`Graph loaded in ${tsGraphDone - tsWsDone}ms`);
 
-  const graph = FoamGraph.fromWorkspace(workspace, true);
   const tags = FoamTags.fromWorkspace(workspace, true);
+  const tsTagsEnd = Date.now();
+  Logger.info(`Tags loaded in ${tsTagsEnd - tsGraphDone}ms`);
 
   const foam: Foam = {
     workspace,

packages/foam-vscode/src/core/model/graph.test.ts

@@ -0,0 +1,681 @@
+import { createTestNote, createTestWorkspace } from '../../test/test-utils';
+import { FoamGraph } from './graph';
+import { URI } from './uri';
+
+describe('Graph', () => {
+  it('should use wikilink slugs to connect nodes', () => {
+    const workspace = createTestWorkspace();
+    const noteA = createTestNote({
+      uri: '/page-a.md',
+      links: [
+        { slug: 'page-b' },
+        { slug: 'page-c' },
+        { slug: 'Page D' },
+        { slug: 'page e' },
+      ],
+    });
+    const noteB = createTestNote({
+      uri: '/page-b.md',
+      links: [{ slug: 'page-a' }],
+    });
+    const noteC = createTestNote({ uri: '/page-c.md' });
+    const noteD = createTestNote({ uri: '/Page D.md' });
+    const noteE = createTestNote({ uri: '/page e.md' });
+
+    workspace
+      .set(noteA)
+      .set(noteB)
+      .set(noteC)
+      .set(noteD)
+      .set(noteE);
+    const graph = FoamGraph.fromWorkspace(workspace);
+
+    expect(graph.getBacklinks(noteB.uri).map(l => l.source)).toEqual([
+      noteA.uri,
+    ]);
+    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([
+      noteB.uri,
+      noteC.uri,
+      noteD.uri,
+      noteE.uri,
+    ]);
+  });
+
+  it('should include resources and placeholders', () => {
+    const ws = createTestWorkspace();
+    ws.set(
+      createTestNote({
+        uri: '/page-a.md',
+        links: [{ slug: 'placeholder-link' }],
+      })
+    );
+    ws.set(createTestNote({ uri: '/file.pdf' }));
+
+    const graph = FoamGraph.fromWorkspace(ws);
+
+    expect(
+      graph
+        .getAllNodes()
+        .map(uri => uri.path)
+        .sort()
+    ).toEqual(['/file.pdf', '/page-a.md', 'placeholder-link']);
+  });
+
+  it('should support multiple connections between the same resources', () => {
+    const noteA = createTestNote({
+      uri: '/path/to/note-a.md',
+    });
+    const noteB = createTestNote({
+      uri: '/note-b.md',
+      links: [{ to: noteA.uri.path }, { to: noteA.uri.path }],
+    });
+    const ws = createTestWorkspace()
+      .set(noteA)
+      .set(noteB);
+    const graph = FoamGraph.fromWorkspace(ws);
+    expect(graph.getBacklinks(noteA.uri)).toEqual([
+      {
+        source: noteB.uri,
+        target: noteA.uri,
+        link: expect.objectContaining({ type: 'link' }),
+      },
+      {
+        source: noteB.uri,
+        target: noteA.uri,
+        link: expect.objectContaining({ type: 'link' }),
+      },
+    ]);
+  });
+
+  it('should keep the connection when removing a single link amongst several between two resources', () => {
+    const noteA = createTestNote({
+      uri: '/path/to/note-a.md',
+    });
+    const noteB = createTestNote({
+      uri: '/note-b.md',
+      links: [{ to: noteA.uri.path }, { to: noteA.uri.path }],
+    });
+    const ws = createTestWorkspace()
+      .set(noteA)
+      .set(noteB);
+    const graph = FoamGraph.fromWorkspace(ws, true);
+
+    expect(graph.getBacklinks(noteA.uri).length).toEqual(2);
+
+    const noteBBis = createTestNote({
+      uri: '/note-b.md',
+      links: [{ to: noteA.uri.path }],
+    });
+    ws.set(noteBBis);
+    expect(graph.getBacklinks(noteA.uri).length).toEqual(1);
+
+    ws.dispose();
+    graph.dispose();
+  });
+
+  it('should create inbound connections for target note', () => {
+    const noteA = createTestNote({
+      uri: '/path/to/page-a.md',
+      links: [{ slug: 'page-b' }],
+    });
+    const ws = createTestWorkspace()
+      .set(noteA)
+      .set(
+        createTestNote({
+          uri: '/somewhere/page-b.md',
+          links: [{ slug: 'page-a' }],
+        })
+      )
+      .set(
+        createTestNote({
+          uri: '/path/another/page-c.md',
+          links: [{ slug: '/path/to/page-a' }],
+        })
+      )
+      .set(
+        createTestNote({
+          uri: '/absolute/path/page-d.md',
+          links: [{ slug: '../to/page-a.md' }],
+        })
+      );
+    const graph = FoamGraph.fromWorkspace(ws);
+
+    expect(
+      graph
+        .getBacklinks(noteA.uri)
+        .map(link => link.source.path)
+        .sort()
+    ).toEqual(['/path/another/page-c.md', '/somewhere/page-b.md']);
+  });
+
+  it('should support attachments', () => {
+    const noteA = createTestNote({
+      uri: '/path/to/page-a.md',
+      links: [
+        // wikilink with extension
+        { slug: 'attachment-a.pdf' },
+        // wikilink without extension
+        { slug: 'attachment-b' },
+      ],
+    });
+    const attachmentA = createTestNote({
+      uri: '/path/to/more/attachment-a.pdf',
+    });
+    const attachmentB = createTestNote({
+      uri: '/path/to/more/attachment-b.pdf',
+    });
+    const ws = createTestWorkspace();
+    ws.set(noteA)
+      .set(attachmentA)
+      .set(attachmentB);
+    const graph = FoamGraph.fromWorkspace(ws);
+
+    expect(graph.getBacklinks(attachmentA.uri).map(l => l.source)).toEqual([
+      noteA.uri,
+    ]);
+    // Attachments require extension
+    expect(graph.getBacklinks(attachmentB.uri).map(l => l.source)).toEqual([]);
+  });
+
+  it('should resolve conflicts alphabetically - part 1', () => {
+    const noteA = createTestNote({
+      uri: '/path/to/page-a.md',
+      links: [{ slug: 'attachment-a.pdf' }],
+    });
+    const attachmentA = createTestNote({
+      uri: '/path/to/more/attachment-a.pdf',
+    });
+    const attachmentABis = createTestNote({
+      uri: '/path/to/attachment-a.pdf',
+    });
+    const ws = createTestWorkspace();
+    ws.set(noteA)
+      .set(attachmentA)
+      .set(attachmentABis);
+    const graph = FoamGraph.fromWorkspace(ws);
+
+    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([
+      attachmentABis.uri,
+    ]);
+  });
+
+  it('should resolve conflicts alphabetically - part 2', () => {
+    const noteA = createTestNote({
+      uri: '/path/to/page-a.md',
+      links: [{ slug: 'attachment-a.pdf' }],
+    });
+    const attachmentA = createTestNote({
+      uri: '/path/to/more/attachment-a.pdf',
+    });
+    const attachmentABis = createTestNote({
+      uri: '/path/to/attachment-a.pdf',
+    });
+    const ws = createTestWorkspace();
+    ws.set(noteA)
+      .set(attachmentABis)
+      .set(attachmentA);
+    const graph = FoamGraph.fromWorkspace(ws);
+
+    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([
+      attachmentABis.uri,
+    ]);
+  });
+});
+
+describe('Placeholders', () => {
+  it('should treat direct links to non-existing files as placeholders', () => {
+    const ws = createTestWorkspace();
+    const noteA = createTestNote({
+      uri: '/somewhere/from/page-a.md',
+      links: [{ to: '../page-b.md' }, { to: '/path/to/page-c.md' }],
+    });
+    ws.set(noteA);
+    const graph = FoamGraph.fromWorkspace(ws);
+
+    expect(graph.getAllConnections()[0]).toEqual({
+      source: noteA.uri,
+      target: URI.placeholder('/somewhere/page-b.md'),
+      link: expect.objectContaining({ type: 'link' }),
+    });
+    expect(graph.getAllConnections()[1]).toEqual({
+      source: noteA.uri,
+      target: URI.placeholder('/path/to/page-c.md'),
+      link: expect.objectContaining({ type: 'link' }),
+    });
+  });
+
+  it('should treat wikilinks without matching file as placeholders', () => {
+    const ws = createTestWorkspace();
+    const noteA = createTestNote({
+      uri: '/somewhere/page-a.md',
+      links: [{ slug: 'page-b' }],
+    });
+    ws.set(noteA);
+    const graph = FoamGraph.fromWorkspace(ws);
+
+    expect(graph.getAllConnections()[0]).toEqual({
+      source: noteA.uri,
+      target: URI.placeholder('page-b'),
+      link: expect.objectContaining({ type: 'wikilink' }),
+    });
+  });
+
+  it('should treat wikilink with definition to non-existing file as placeholders', () => {
+    const ws = createTestWorkspace();
+    const noteA = createTestNote({
+      uri: '/somewhere/page-a.md',
+      links: [{ slug: 'page-b' }, { slug: 'page-c' }],
+    });
+    noteA.definitions.push({
+      label: 'page-b',
+      url: './page-b.md',
+    });
+    noteA.definitions.push({
+      label: 'page-c',
+      url: '/path/to/page-c.md',
+    });
+    ws.set(noteA).set(
+      createTestNote({ uri: '/different/location/for/note-b.md' })
+    );
+    const graph = FoamGraph.fromWorkspace(ws);
+
+    expect(graph.getAllConnections()[0]).toEqual({
+      source: noteA.uri,
+      target: URI.placeholder('/somewhere/page-b.md'),
+      link: expect.objectContaining({ type: 'wikilink' }),
+    });
+    expect(graph.getAllConnections()[1]).toEqual({
+      source: noteA.uri,
+      target: URI.placeholder('/path/to/page-c.md'),
+      link: expect.objectContaining({ type: 'wikilink' }),
+    });
+  });
+
+  it('should work with a placeholder named like a JS prototype property', () => {
+    const ws = createTestWorkspace();
+    const noteA = createTestNote({
+      uri: '/page-a.md',
+      links: [{ slug: 'constructor' }],
+    });
+    ws.set(noteA);
+    const graph = FoamGraph.fromWorkspace(ws);
+
+    expect(
+      graph
+        .getAllNodes()
+        .map(uri => uri.path)
+        .sort()
+    ).toEqual(['/page-a.md', 'constructor']);
+  });
+});
+
+describe('Regenerating graph after workspace changes', () => {
+  it('should update links when modifying a resource', () => {
+    const noteA = createTestNote({
+      uri: '/path/to/page-a.md',
+      links: [{ slug: 'page-b' }],
+    });
+    const noteB = createTestNote({
+      uri: '/path/to/another/page-b.md',
+      links: [{ slug: 'page-c' }],
+    });
+    const noteC = createTestNote({
+      uri: '/path/to/more/page-c.md',
+    });
+    const ws = createTestWorkspace();
+    ws.set(noteA)
+      .set(noteB)
+      .set(noteC);
+    let graph = FoamGraph.fromWorkspace(ws);
+
+    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([noteB.uri]);
+    expect(graph.getBacklinks(noteB.uri).map(l => l.source)).toEqual([
+      noteA.uri,
+    ]);
+    expect(graph.getBacklinks(noteC.uri).map(l => l.source)).toEqual([
+      noteB.uri,
+    ]);
+
+    // update the note
+    const noteABis = createTestNote({
+      uri: '/path/to/page-a.md',
+      links: [{ slug: 'page-c' }],
+    });
+    ws.set(noteABis);
+    // change is not propagated immediately
+    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([noteB.uri]);
+    expect(graph.getBacklinks(noteB.uri).map(l => l.source)).toEqual([
+      noteA.uri,
+    ]);
+    expect(graph.getBacklinks(noteC.uri).map(l => l.source)).toEqual([
+      noteB.uri,
+    ]);
+
+    // recompute the links
+    graph = FoamGraph.fromWorkspace(ws);
+    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([noteC.uri]);
+    expect(graph.getBacklinks(noteB.uri).map(l => l.source)).toEqual([]);
+    expect(
+      graph
+        .getBacklinks(noteC.uri)
+        .map(link => link.source.path)
+        .sort()
+    ).toEqual(['/path/to/another/page-b.md', '/path/to/page-a.md']);
+    graph.dispose();
+    ws.dispose();
+  });
+
+  it('should produce a placeholder for wikilinks pointing to a removed resource', () => {
+    const noteA = createTestNote({
+      uri: '/path/to/page-a.md',
+      links: [{ slug: 'page-b' }],
+    });
+    const noteB = createTestNote({
+      uri: '/path/to/another/page-b.md',
+    });
+    const ws = createTestWorkspace();
+    ws.set(noteA).set(noteB);
+    const graph = FoamGraph.fromWorkspace(ws);
+
+    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([noteB.uri]);
+    expect(graph.getBacklinks(noteB.uri).map(l => l.source)).toEqual([
+      noteA.uri,
+    ]);
+    expect(ws.get(noteB.uri).type).toEqual('note');
+
+    // remove note-b
+    ws.delete(noteB.uri);
+    const graph2 = FoamGraph.fromWorkspace(ws);
+
+    expect(() => ws.get(noteB.uri)).toThrow();
+    expect(graph2.contains(URI.placeholder('page-b'))).toBeTruthy();
+  });
+
+  it('should turn a placeholder into a connection when adding a resource matching a wikilink', () => {
+    const noteA = createTestNote({
+      uri: '/path/to/page-a.md',
+      links: [{ slug: 'page-b' }],
+    });
+    const ws = createTestWorkspace();
+    ws.set(noteA);
+    const graph = FoamGraph.fromWorkspace(ws);
+
+    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([
+      URI.placeholder('page-b'),
+    ]);
+    expect(graph.contains(URI.placeholder('page-b'))).toBeTruthy();
+
+    // add note-b
+    const noteB = createTestNote({
+      uri: '/path/to/another/page-b.md',
+    });
+
+    ws.set(noteB);
+    FoamGraph.fromWorkspace(ws);
+
+    expect(() => ws.get(URI.placeholder('page-b'))).toThrow();
+    expect(ws.get(noteB.uri).type).toEqual('note');
+  });
+
+  it('should produce a placeholder for direct links pointing to a removed resource', () => {
+    const noteA = createTestNote({
+      uri: '/path/to/page-a.md',
+      links: [{ to: '/path/to/another/page-b.md' }],
+    });
+    const noteB = createTestNote({
+      uri: '/path/to/another/page-b.md',
+    });
+    const ws = createTestWorkspace();
+    ws.set(noteA).set(noteB);
+    const graph = FoamGraph.fromWorkspace(ws);
+
+    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([noteB.uri]);
+    expect(graph.getBacklinks(noteB.uri).map(l => l.source)).toEqual([
+      noteA.uri,
+    ]);
+    expect(ws.get(noteB.uri).type).toEqual('note');
+
+    // remove note-b
+    ws.delete(noteB.uri);
+    const graph2 = FoamGraph.fromWorkspace(ws);
+
+    expect(() => ws.get(noteB.uri)).toThrow();
+    expect(
+      graph2.contains(URI.placeholder('/path/to/another/page-b.md'))
+    ).toBeTruthy();
+  });
+
+  it('should turn a placeholder into a connection when adding a resource matching a direct link', () => {
+    const noteA = createTestNote({
+      uri: '/path/to/page-a.md',
+      links: [{ to: '/path/to/another/page-b.md' }],
+    });
+    const ws = createTestWorkspace();
+    ws.set(noteA);
+    const graph = FoamGraph.fromWorkspace(ws);
+
+    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([
+      URI.placeholder('/path/to/another/page-b.md'),
+    ]);
+    expect(() =>
+      ws.get(URI.placeholder('/path/to/another/page-b.md'))
+    ).toThrow();
+
+    // add note-b
+    const noteB = createTestNote({
+      uri: '/path/to/another/page-b.md',
+    });
+
+    ws.set(noteB);
+    FoamGraph.fromWorkspace(ws);
+
+    expect(() => ws.get(URI.placeholder('page-b'))).toThrow();
+    expect(ws.get(noteB.uri).type).toEqual('note');
+  });
+
+  it('should remove the placeholder from graph when removing all links to it', () => {
+    const noteA = createTestNote({
+      uri: '/path/to/page-a.md',
+      links: [{ to: '/path/to/another/page-b.md' }],
+    });
+    const ws = createTestWorkspace().set(noteA);
+    const graph = FoamGraph.fromWorkspace(ws);
+    expect(
+      graph.contains(URI.placeholder('/path/to/another/page-b.md'))
+    ).toBeTruthy();
+
+    // update the note
+    const noteABis = createTestNote({
+      uri: '/path/to/page-a.md',
+      links: [],
+    });
+    ws.set(noteABis);
+    const graph2 = FoamGraph.fromWorkspace(ws);
+
+    expect(
+      graph2.contains(URI.placeholder('/path/to/another/page-b.md'))
+    ).toBeFalsy();
+  });
+});
+
+describe('Updating graph on workspace state', () => {
+  it('should automatically update the links when modifying a resource', () => {
+    const noteA = createTestNote({
+      uri: '/path/to/page-a.md',
+      links: [{ slug: 'page-b' }],
+    });
+    const noteB = createTestNote({
+      uri: '/path/to/another/page-b.md',
+      links: [{ slug: 'page-c' }],
+    });
+    const noteC = createTestNote({
+      uri: '/path/to/more/page-c.md',
+    });
+    const ws = createTestWorkspace();
+    ws.set(noteA)
+      .set(noteB)
+      .set(noteC);
+    const graph = FoamGraph.fromWorkspace(ws, true);
+
+    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([noteB.uri]);
+    expect(graph.getBacklinks(noteB.uri).map(l => l.source)).toEqual([
+      noteA.uri,
+    ]);
+    expect(graph.getBacklinks(noteC.uri).map(l => l.source)).toEqual([
+      noteB.uri,
+    ]);
+
+    // update the note
+    const noteABis = createTestNote({
+      uri: '/path/to/page-a.md',
+      links: [{ slug: 'page-c' }],
+    });
+    ws.set(noteABis);
+
+    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([noteC.uri]);
+    expect(graph.getBacklinks(noteB.uri).map(l => l.source)).toEqual([]);
+    expect(
+      graph
+        .getBacklinks(noteC.uri)
+        .map(link => link.source.path)
+        .sort()
+    ).toEqual(['/path/to/another/page-b.md', '/path/to/page-a.md']);
+    ws.dispose();
+    graph.dispose();
+  });
+
+  it('should produce a placeholder for wikilinks pointing to a removed resource', () => {
+    const noteA = createTestNote({
+      uri: '/path/to/page-a.md',
+      links: [{ slug: 'page-b' }],
+    });
+    const noteB = createTestNote({
+      uri: '/path/to/another/page-b.md',
+    });
+    const ws = createTestWorkspace();
+    ws.set(noteA).set(noteB);
+    const graph = FoamGraph.fromWorkspace(ws, true);
+
+    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([noteB.uri]);
+    expect(graph.getBacklinks(noteB.uri).map(l => l.source)).toEqual([
+      noteA.uri,
+    ]);
+    expect(ws.get(noteB.uri).type).toEqual('note');
+
+    // remove note-b
+    ws.delete(noteB.uri);
+
+    expect(() => ws.get(noteB.uri)).toThrow();
+    ws.dispose();
+    graph.dispose();
+  });
+
+  it('should turn a placeholder into a connection when adding a resource matching a wikilink', () => {
+    const noteA = createTestNote({
+      uri: '/path/to/page-a.md',
+      links: [{ slug: 'page-b' }],
+    });
+    const ws = createTestWorkspace();
+    ws.set(noteA);
+    const graph = FoamGraph.fromWorkspace(ws, true);
+
+    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([
+      URI.placeholder('page-b'),
+    ]);
+
+    // add note-b
+    const noteB = createTestNote({
+      uri: '/path/to/another/page-b.md',
+    });
+
+    ws.set(noteB);
+
+    expect(() => ws.get(URI.placeholder('page-b'))).toThrow();
+    expect(ws.get(noteB.uri).type).toEqual('note');
+    ws.dispose();
+    graph.dispose();
+  });
+
+  it('should produce a placeholder for direct links pointing to a removed resource', () => {
+    const noteA = createTestNote({
+      uri: '/path/to/page-a.md',
+      links: [{ to: '/path/to/another/page-b.md' }],
+    });
+    const noteB = createTestNote({
+      uri: '/path/to/another/page-b.md',
+    });
+    const ws = createTestWorkspace();
+    ws.set(noteA).set(noteB);
+    const graph = FoamGraph.fromWorkspace(ws, true);
+
+    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([noteB.uri]);
+    expect(graph.getBacklinks(noteB.uri).map(l => l.source)).toEqual([
+      noteA.uri,
+    ]);
+    expect(ws.get(noteB.uri).type).toEqual('note');
+
+    // remove note-b
+    ws.delete(noteB.uri);
+
+    expect(() => ws.get(noteB.uri)).toThrow();
+    expect(
+      graph.contains(URI.placeholder('/path/to/another/page-b.md'))
+    ).toBeTruthy();
+    ws.dispose();
+    graph.dispose();
+  });
+
+  it('should turn a placeholder into a connection when adding a resource matching a direct link', () => {
+    const noteA = createTestNote({
+      uri: '/path/to/page-a.md',
+      links: [{ to: '/path/to/another/page-b.md' }],
+    });
+    const ws = createTestWorkspace();
+    ws.set(noteA);
+    const graph = FoamGraph.fromWorkspace(ws, true);
+
+    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([
+      URI.placeholder('/path/to/another/page-b.md'),
+    ]);
+    expect(
+      graph.contains(URI.placeholder('/path/to/another/page-b.md'))
+    ).toBeTruthy();
+
+    // add note-b
+    const noteB = createTestNote({
+      uri: '/path/to/another/page-b.md',
+    });
+
+    ws.set(noteB);
+
+    expect(() => ws.get(URI.placeholder('page-b'))).toThrow();
+    expect(ws.get(noteB.uri).type).toEqual('note');
+    ws.dispose();
+    graph.dispose();
+  });
+
+  it('should remove the placeholder from graph when removing all links to it', () => {
+    const noteA = createTestNote({
+      uri: '/path/to/page-a.md',
+      links: [{ to: '/path/to/another/page-b.md' }],
+    });
+    const ws = createTestWorkspace();
+    ws.set(noteA);
+    const graph = FoamGraph.fromWorkspace(ws, true);
+    expect(
+      graph.contains(URI.placeholder('/path/to/another/page-b.md'))
+    ).toBeTruthy();
+
+    // update the note
+    const noteABis = createTestNote({
+      uri: '/path/to/page-a.md',
+      links: [],
+    });
+    ws.set(noteABis);
+    expect(
+      graph.contains(URI.placeholder('/path/to/another/page-b.md'))
+    ).toBeFalsy();
+    ws.dispose();
+    graph.dispose();
+  });
+});

packages/foam-vscode/src/core/model/graph.ts

@@ -1,10 +1,10 @@
-import { diff } from 'fast-array-diff';
-import { isEqual } from 'lodash';
-import { Resource, ResourceLink } from './note';
+import { debounce } from 'lodash';
+import { ResourceLink } from './note';
 import { URI } from './uri';
 import { FoamWorkspace } from './workspace';
-import { Range } from './range';
 import { IDisposable } from '../common/lifecycle';
+import { Logger } from '../utils/log';
+import { Emitter } from '../common/event';
 
 export type Connection = {
   source: URI;
@@ -29,6 +29,9 @@ export class FoamGraph implements IDisposable {
    */
   public readonly backlinks: Map<string, Connection[]> = new Map();
 
+  private onDidUpdateEmitter = new Emitter<void>();
+  onDidUpdate = this.onDidUpdateEmitter.event;
+
   /**
    * List of disposables to destroy with the workspace
    */
@@ -72,91 +75,46 @@ export class FoamGraph implements IDisposable {
    *
    * @param workspace the target workspace
    * @param keepMonitoring whether to recompute the links when the workspace changes
+   * @param debounceFor how long to wait between change detection and graph update
    * @returns the FoamGraph
    */
   public static fromWorkspace(
     workspace: FoamWorkspace,
-    keepMonitoring = false
+    keepMonitoring = false,
+    debounceFor = 0
   ): FoamGraph {
     const graph = new FoamGraph(workspace);
-
-    workspace.list().forEach(resource => graph.resolveResource(resource));
+    graph.update();
     if (keepMonitoring) {
+      const updateGraph =
+        debounceFor > 0
+          ? debounce(graph.update.bind(graph), 500)
+          : graph.update.bind(graph);
       graph.disposables.push(
-        workspace.onDidAdd(resource => {
-          graph.updateLinksRelatedToAddedResource(resource);
-        }),
-        workspace.onDidUpdate(change => {
-          graph.updateLinksForResource(change.old, change.new);
-        }),
-        workspace.onDidDelete(resource => {
-          graph.updateLinksRelatedToDeletedResource(resource);
-        })
+        workspace.onDidAdd(updateGraph),
+        workspace.onDidUpdate(updateGraph),
+        workspace.onDidDelete(updateGraph)
       );
     }
     return graph;
   }
 
-  private updateLinksRelatedToAddedResource(resource: Resource) {
-    // check if any existing connection can be filled by new resource
-    const resourcesToUpdate: URI[] = [];
-    for (const placeholderId of this.placeholders.keys()) {
-      // quick and dirty check for affected resources
-      if (resource.uri.path.endsWith(placeholderId + '.md')) {
-        resourcesToUpdate.push(
-          ...this.backlinks.get(placeholderId).map(c => c.source)
-        );
-        // resourcesToUpdate.push(resource);
+  private update() {
+    const start = Date.now();
+    this.backlinks.clear();
+    this.links.clear();
+    this.placeholders.clear();
+
+    for (const resource of this.workspace.resources()) {
+      for (const link of resource.links) {
+        const targetUri = this.workspace.resolveLink(resource, link);
+        this.connect(resource.uri, targetUri, link);
       }
     }
-    resourcesToUpdate.forEach(res =>
-      this.resolveResource(this.workspace.get(res))
-    );
-    // resolve the resource
-    this.resolveResource(resource);
-  }
 
-  private updateLinksForResource(oldResource: Resource, newResource: Resource) {
-    if (oldResource.uri.path !== newResource.uri.path) {
-      throw new Error(
-        'Unexpected State: update should only be called on same resource ' +
-          {
-            old: oldResource,
-            new: newResource,
-          }
-      );
-    }
-    if (oldResource.type === 'note' && newResource.type === 'note') {
-      const patch = diff(oldResource.links, newResource.links, isEqual);
-      patch.removed.forEach(link => {
-        const target = this.workspace.resolveLink(oldResource, link);
-        return this.disconnect(oldResource.uri, target, link);
-      }, this);
-      patch.added.forEach(link => {
-        const target = this.workspace.resolveLink(newResource, link);
-        return this.connect(newResource.uri, target, link);
-      }, this);
-    }
-    return this;
-  }
-
-  private updateLinksRelatedToDeletedResource(resource: Resource) {
-    const uri = resource.uri;
-
-    // remove forward links from old resource
-    const resourcesPointedByDeletedNote = this.links.get(uri.path) ?? [];
-    this.links.delete(uri.path);
-    resourcesPointedByDeletedNote.forEach(connection =>
-      this.disconnect(uri, connection.target, connection.link)
-    );
-
-    // recompute previous links to old resource
-    const notesPointingToDeletedResource = this.backlinks.get(uri.path) ?? [];
-    this.backlinks.delete(uri.path);
-    notesPointingToDeletedResource.forEach(link =>
-      this.resolveResource(this.workspace.get(link.source))
-    );
-    return this;
+    const end = Date.now();
+    Logger.info(`Graph updated in ${end - start}ms`);
+    this.onDidUpdateEmitter.fire();
   }
 
   private connect(source: URI, target: URI, link: ResourceLink) {
@@ -167,10 +125,9 @@ export class FoamGraph implements IDisposable {
     }
     this.links.get(source.path)?.push(connection);
 
-    if (!this.backlinks.get(target.path)) {
+    if (!this.backlinks.has(target.path)) {
       this.backlinks.set(target.path, []);
     }
-
     this.backlinks.get(target.path)?.push(connection);
 
     if (target.isPlaceholder()) {
@@ -179,65 +136,9 @@ export class FoamGraph implements IDisposable {
     return this;
   }
 
-  /**
-   * Removes a connection, or all connections, between the source and
-   * target resources
-   *
-   * @param workspace the Foam workspace
-   * @param source the source resource
-   * @param target the target resource
-   * @param link the link reference, or `true` to remove all links
-   * @returns the updated Foam workspace
-   */
-  private disconnect(source: URI, target: URI, link: ResourceLink | true) {
-    const connectionsToKeep =
-      link === true
-        ? (c: Connection) =>
-            !source.isEqual(c.source) || !target.isEqual(c.target)
-        : (c: Connection) => !isSameConnection({ source, target, link }, c);
-
-    this.links.set(
-      source.path,
-      this.links.get(source.path)?.filter(connectionsToKeep) ?? []
-    );
-    if (this.links.get(source.path)?.length === 0) {
-      this.links.delete(source.path);
-    }
-    this.backlinks.set(
-      target.path,
-      this.backlinks.get(target.path)?.filter(connectionsToKeep) ?? []
-    );
-    if (this.backlinks.get(target.path)?.length === 0) {
-      this.backlinks.delete(target.path);
-      if (target.isPlaceholder()) {
-        this.placeholders.delete(uriToPlaceholderId(target));
-      }
-    }
-    return this;
-  }
-
-  public resolveResource(resource: Resource) {
-    this.links.delete(resource.uri.path);
-    // prettier-ignore
-    resource.links.forEach(link => {
-      const targetUri = this.workspace.resolveLink(resource, link);
-      this.connect(resource.uri, targetUri, link);
-    });
-    return this;
-  }
-
   public dispose(): void {
+    this.onDidUpdateEmitter.dispose();
     this.disposables.forEach(d => d.dispose());
     this.disposables = [];
   }
 }
-
-// TODO move these utility fns to appropriate places
-
-const isSameConnection = (a: Connection, b: Connection) =>
-  a.source.isEqual(b.source) &&
-  a.target.isEqual(b.target) &&
-  isSameLink(a.link, b.link);
-
-const isSameLink = (a: ResourceLink, b: ResourceLink) =>
-  a.type === b.type && Range.isEqual(a.range, b.range);

packages/foam-vscode/src/core/model/note.ts

@@ -9,23 +9,12 @@ export interface NoteSource {
   eol: string;
 }
 
-export interface WikiLink {
-  type: 'wikilink';
-  target: string;
-  label: string;
+export interface ResourceLink {
+  type: 'wikilink' | 'link';
   rawText: string;
   range: Range;
 }
 
-export interface DirectLink {
-  type: 'link';
-  label: string;
-  target: string;
-  range: Range;
-}
-
-export type ResourceLink = WikiLink | DirectLink;
-
 export interface NoteLinkDefinition {
   label: string;
   url: string;

packages/foam-vscode/src/core/model/tags.test.ts

@@ -59,7 +59,8 @@ describe('FoamTags', () => {
       tags: ['primary'],
     });
 
-    tags.updateResourceWithinTagIndex(taglessPage, newPage);
+    ws.set(newPage);
+    tags.update();
 
     expect(tags.tags).toEqual(new Map([['primary', [page.uri, newPage.uri]]]));
   });
@@ -86,7 +87,8 @@ describe('FoamTags', () => {
       tags: ['new'],
     });
 
-    tags.updateResourceWithinTagIndex(page, pageEdited);
+    ws.set(pageEdited);
+    tags.update();
 
     expect(tags.tags).toEqual(new Map([['new', [page.uri]]]));
   });
@@ -112,12 +114,14 @@ describe('FoamTags', () => {
       tags: ['primary'],
     });
 
-    tags.updateResourceWithinTagIndex(page, pageEdited);
+    ws.delete(page.uri);
+    ws.set(pageEdited);
+    tags.update();
 
     expect(tags.tags).toEqual(new Map([['primary', [pageEdited.uri]]]));
   });
 
-  it('Updates the metadata of a tag when a note is delete', () => {
+  it('Updates the metadata of a tag when a note is deleted', () => {
     const ws = createTestWorkspace();
 
     const page = createTestNote({
@@ -131,7 +135,8 @@ describe('FoamTags', () => {
     const tags = FoamTags.fromWorkspace(ws);
     expect(tags.tags).toEqual(new Map([['primary', [page.uri]]]));
 
-    tags.removeResourceFromTagIndex(page);
+    ws.delete(page.uri);
+    tags.update();
 
     expect(tags.tags).toEqual(new Map());
   });

packages/foam-vscode/src/core/model/tags.ts

@@ -1,81 +1,66 @@
 import { FoamWorkspace } from './workspace';
 import { URI } from './uri';
-import { Resource } from './note';
 import { IDisposable } from '../common/lifecycle';
+import { debounce } from 'lodash';
+import { Emitter } from '../common/event';
 
 export class FoamTags implements IDisposable {
   public readonly tags: Map<string, URI[]> = new Map();
 
+  private onDidUpdateEmitter = new Emitter<void>();
+  onDidUpdate = this.onDidUpdateEmitter.event;
+
   /**
    * List of disposables to destroy with the tags
    */
   private disposables: IDisposable[] = [];
 
+  constructor(private readonly workspace: FoamWorkspace) {}
+
   /**
    * Computes all tags in the workspace and keep them up-to-date
    *
    * @param workspace the target workspace
    * @param keepMonitoring whether to recompute the links when the workspace changes
+   * @param debounceFor how long to wait between change detection and tags update
    * @returns the FoamTags
    */
   public static fromWorkspace(
     workspace: FoamWorkspace,
-    keepMonitoring = false
+    keepMonitoring = false,
+    debounceFor = 0
   ): FoamTags {
-    const tags = new FoamTags();
-
-    workspace
-      .list()
-      .forEach(resource => tags.addResourceFromTagIndex(resource));
+    const tags = new FoamTags(workspace);
+    tags.update();
 
     if (keepMonitoring) {
+      const updateTags =
+        debounceFor > 0
+          ? debounce(tags.update.bind(tags), 500)
+          : tags.update.bind(tags);
       tags.disposables.push(
-        workspace.onDidAdd(resource => {
-          tags.addResourceFromTagIndex(resource);
-        }),
-        workspace.onDidUpdate(change => {
-          tags.updateResourceWithinTagIndex(change.old, change.new);
-        }),
-        workspace.onDidDelete(resource => {
-          tags.removeResourceFromTagIndex(resource);
-        })
+        workspace.onDidAdd(updateTags),
+        workspace.onDidUpdate(updateTags),
+        workspace.onDidDelete(updateTags)
       );
     }
     return tags;
   }
 
+  update(): void {
+    this.tags.clear();
+    for (const resource of this.workspace.resources()) {
+      for (const tag of new Set(resource.tags.map(t => t.label))) {
+        const tagMeta = this.tags.get(tag) ?? [];
+        tagMeta.push(resource.uri);
+        this.tags.set(tag, tagMeta);
+      }
+    }
+    this.onDidUpdateEmitter.fire();
+  }
+
   dispose(): void {
     this.disposables.forEach(d => d.dispose());
     this.disposables = [];
   }
-
-  updateResourceWithinTagIndex(oldResource: Resource, newResource: Resource) {
-    this.removeResourceFromTagIndex(oldResource);
-    this.addResourceFromTagIndex(newResource);
-  }
-
-  addResourceFromTagIndex(resource: Resource) {
-    new Set(resource.tags.map(t => t.label)).forEach(tag => {
-      const tagMeta = this.tags.get(tag) ?? [];
-      tagMeta.push(resource.uri);
-      this.tags.set(tag, tagMeta);
-    });
-  }
-
-  removeResourceFromTagIndex(resource: Resource) {
-    resource.tags.forEach(t => {
-      const tag = t.label;
-      if (this.tags.has(tag)) {
-        const remainingLocations = this.tags
-          .get(tag)
-          ?.filter(uri => !uri.isEqual(resource.uri));
-
-        if (remainingLocations && remainingLocations.length > 0) {
-          this.tags.set(tag, remainingLocations);
-        } else {
-          this.tags.delete(tag);
-        }
-      }
-    });
-  }
 }

packages/foam-vscode/src/core/model/uri.test.ts

@@ -71,5 +71,13 @@ describe('Foam URI', () => {
     expect(URI.file('/my/file.markdown').resolve('../hello')).toEqual(
       URI.file('/hello.markdown')
     );
+    expect(
+      URI.file('/path/to/a/note.md').resolve('../another-note.md')
+    ).toEqual(URI.file('/path/to/another-note.md'));
+    expect(
+      URI.file('/path/to/a/note.md').relativeTo(
+        URI.file('/path/to/another/note.md').getDirectory()
+      )
+    ).toEqual(URI.file('../a/note.md'));
   });
 });

packages/foam-vscode/src/core/model/uri.ts

@@ -122,6 +122,13 @@ export class URI {
     return new URI({ ...this, fragment });
   }
 
+  /**
+   * Returns a URI without the fragment and query information
+   */
+  asPlain(): URI {
+    return new URI({ ...this, fragment: '', query: '' });
+  }
+
   isPlaceholder(): boolean {
     return this.scheme === 'placeholder';
   }

packages/foam-vscode/src/core/model/workspace.test.ts

@@ -1,5 +1,4 @@
 import { FoamWorkspace } from './workspace';
-import { FoamGraph } from './graph';
 import { Logger } from '../utils/log';
 import { URI } from './uri';
 import { createTestNote, createTestWorkspace } from '../../test/test-utils';
@@ -7,7 +6,7 @@ import { createTestNote, createTestWorkspace } from '../../test/test-utils';
 Logger.setLevel('error');
 
 describe('Workspace resources', () => {
-  it('Adds notes to workspace', () => {
+  it('should allow adding notes to the workspace', () => {
     const ws = createTestWorkspace();
     ws.set(createTestNote({ uri: '/page-a.md' }));
     ws.set(createTestNote({ uri: '/page-b.md' }));
@@ -21,7 +20,7 @@ describe('Workspace resources', () => {
     ).toEqual(['/page-a.md', '/page-b.md', '/page-c.md']);
   });
 
-  it('Listing resources includes all notes', () => {
+  it('should includes all notes when listing resources', () => {
     const ws = createTestWorkspace();
     ws.set(createTestNote({ uri: '/page-a.md' }));
     ws.set(createTestNote({ uri: '/file.pdf' }));
@@ -34,7 +33,7 @@ describe('Workspace resources', () => {
     ).toEqual(['/file.pdf', '/page-a.md']);
   });
 
-  it('Fails if getting non-existing note', () => {
+  it('should fail when trying to get a non-existing note', () => {
     const noteA = createTestNote({
       uri: '/path/to/page-a.md',
     });
@@ -47,21 +46,21 @@ describe('Workspace resources', () => {
     expect(() => ws.get(uri)).toThrow();
   });
 
-  it('Should work with a resource named like a JS prototype property', () => {
+  it('should work with a resource named like a JS prototype property', () => {
     const ws = createTestWorkspace();
     const noteA = createTestNote({ uri: '/somewhere/constructor.md' });
     ws.set(noteA);
     expect(ws.list()).toEqual([noteA]);
   });
 
-  it('#851 - listing by ID should not return files with same suffix', () => {
+  it('should not return files with same suffix when listing by ID - #851', () => {
     const ws = createTestWorkspace()
       .set(createTestNote({ uri: 'test-file.md' }))
       .set(createTestNote({ uri: 'file.md' }));
     expect(ws.listByIdentifier('file').length).toEqual(1);
   });
 
-  it('Support dendron-style names', () => {
+  it('should support dendron-style names', () => {
     const ws = createTestWorkspace()
       .set(createTestNote({ uri: 'note.pdf' }))
       .set(createTestNote({ uri: 'note.md' }))
@@ -80,7 +79,7 @@ describe('Workspace resources', () => {
     }
   });
 
-  it('Should include fragment when finding resource URI', () => {
+  it('should keep the fragment information when finding a resource', () => {
     const ws = createTestWorkspace()
       .set(createTestNote({ uri: 'test-file.md' }))
       .set(createTestNote({ uri: 'file.md' }));
@@ -90,79 +89,6 @@ describe('Workspace resources', () => {
   });
 });
 
-describe('Graph', () => {
-  it('contains notes and placeholders', () => {
-    const ws = createTestWorkspace();
-    ws.set(
-      createTestNote({
-        uri: '/page-a.md',
-        links: [{ slug: 'placeholder-link' }],
-      })
-    );
-    ws.set(createTestNote({ uri: '/file.pdf' }));
-
-    const graph = FoamGraph.fromWorkspace(ws);
-
-    expect(
-      graph
-        .getAllNodes()
-        .map(uri => uri.path)
-        .sort()
-    ).toEqual(['/file.pdf', '/page-a.md', 'placeholder-link']);
-  });
-
-  it('Supports multiple connections between the same resources', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/note-a.md',
-    });
-    const noteB = createTestNote({
-      uri: '/note-b.md',
-      links: [{ to: noteA.uri.path }, { to: noteA.uri.path }],
-    });
-    const ws = createTestWorkspace()
-      .set(noteA)
-      .set(noteB);
-    const graph = FoamGraph.fromWorkspace(ws);
-    expect(graph.getBacklinks(noteA.uri)).toEqual([
-      {
-        source: noteB.uri,
-        target: noteA.uri,
-        link: expect.objectContaining({ type: 'link' }),
-      },
-      {
-        source: noteB.uri,
-        target: noteA.uri,
-        link: expect.objectContaining({ type: 'link' }),
-      },
-    ]);
-  });
-  it('Supports removing a single link amongst several between two resources', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/note-a.md',
-    });
-    const noteB = createTestNote({
-      uri: '/note-b.md',
-      links: [{ to: noteA.uri.path }, { to: noteA.uri.path }],
-    });
-    const ws = createTestWorkspace()
-      .set(noteA)
-      .set(noteB);
-    const graph = FoamGraph.fromWorkspace(ws, true);
-
-    expect(graph.getBacklinks(noteA.uri).length).toEqual(2);
-
-    const noteBBis = createTestNote({
-      uri: '/note-b.md',
-      links: [{ to: noteA.uri.path }],
-    });
-    ws.set(noteBBis);
-    expect(graph.getBacklinks(noteA.uri).length).toEqual(1);
-
-    ws.dispose();
-    graph.dispose();
-  });
-});
-
 describe('Identifier computation', () => {
   it('should compute the minimum identifier to resolve a name clash', () => {
     const first = createTestNote({
@@ -210,7 +136,7 @@ describe('Identifier computation', () => {
     [['/project/home/todo', '/other/todo', '/something/else'], 'car/todo'],
     [['/family/car/todo', '/other/todo'], 'project/car/todo'],
     [[], 'todo'],
-  ])('Find shortest identifier', (haystack, id) => {
+  ])('should find shortest identifier', (haystack, id) => {
     expect(FoamWorkspace.getShortestIdentifier(needle, haystack)).toEqual(id);
   });
 
@@ -225,7 +151,7 @@ describe('Identifier computation', () => {
     expect(identifier).toEqual('car/todo');
   });
 
-  it('should return best guess when no solution is possible', () => {
+  it('should return the best guess when no solution is possible', () => {
     /**
      * In this case there is no way to uniquely identify the element,
      * our fallback is to just return the "least wrong" result, basically
@@ -241,756 +167,23 @@ describe('Identifier computation', () => {
     const identifier = FoamWorkspace.getShortestIdentifier(needle, haystack);
     expect(identifier).toEqual('project/car/todo');
   });
-});
 
-describe('Wikilinks', () => {
-  it('Can be defined with basename, relative path, absolute path, extension', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [
-        // wikilink
-        { slug: 'page-b' },
-        // relative path wikilink
-        { slug: '../another/page-c.md' },
-        // absolute path wikilink
-        { slug: '/absolute/path/page-d' },
-        // wikilink with extension
-        { slug: 'page-e.md' },
-        // wikilink to placeholder
-        { slug: 'placeholder-test' },
-      ],
-    });
-    const ws = createTestWorkspace()
+  it('should ignore elements from the exclude list', () => {
+    const workspace = new FoamWorkspace();
+    const noteA = createTestNote({ uri: '/path/to/note-a.md' });
+    const noteB = createTestNote({ uri: '/path/to/note-b.md' });
+    const noteC = createTestNote({ uri: '/path/to/note-c.md' });
+    const noteD = createTestNote({ uri: '/path/to/note-d.md' });
+    const noteABis = createTestNote({ uri: '/path/to/another/note-a.md' });
+
+    workspace
       .set(noteA)
-      .set(createTestNote({ uri: '/somewhere/page-b.md' }))
-      .set(createTestNote({ uri: '/path/another/page-c.md' }))
-      .set(createTestNote({ uri: '/absolute/path/page-d.md' }))
-      .set(createTestNote({ uri: '/absolute/path/page-e.md' }));
-    const graph = FoamGraph.fromWorkspace(ws);
-
-    expect(
-      graph
-        .getLinks(noteA.uri)
-        .map(link => link.target.path)
-        .sort()
-    ).toEqual([
-      '/absolute/path/page-d.md',
-      '/absolute/path/page-e.md',
-      '/path/another/page-c.md',
-      '/somewhere/page-b.md',
-      'placeholder-test',
-    ]);
-  });
-
-  it('Creates inbound connections for target note', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [{ slug: 'page-b' }],
-    });
-    const ws = createTestWorkspace()
-      .set(noteA)
-      .set(
-        createTestNote({
-          uri: '/somewhere/page-b.md',
-          links: [{ slug: 'page-a' }],
-        })
-      )
-      .set(
-        createTestNote({
-          uri: '/path/another/page-c.md',
-          links: [{ slug: '/path/to/page-a' }],
-        })
-      )
-      .set(
-        createTestNote({
-          uri: '/absolute/path/page-d.md',
-          links: [{ slug: '../to/page-a.md' }],
-        })
-      );
-    const graph = FoamGraph.fromWorkspace(ws);
-
-    expect(
-      graph
-        .getBacklinks(noteA.uri)
-        .map(link => link.source.path)
-        .sort()
-    ).toEqual(['/path/another/page-c.md', '/somewhere/page-b.md']);
-  });
-
-  it('Uses wikilink definitions when available to resolve target', () => {
-    const ws = createTestWorkspace();
-    const noteA = createTestNote({
-      uri: '/somewhere/from/page-a.md',
-      links: [{ slug: 'page-b' }],
-    });
-    noteA.definitions.push({
-      label: 'page-b',
-      url: '../to/page-b.md',
-    });
-    const noteB = createTestNote({
-      uri: '/somewhere/to/page-b.md',
-    });
-    ws.set(noteA).set(noteB);
-    const graph = FoamGraph.fromWorkspace(ws);
-
-    expect(graph.getAllConnections()[0]).toEqual({
-      source: noteA.uri,
-      target: noteB.uri,
-      link: expect.objectContaining({ type: 'wikilink', label: 'page-b' }),
-    });
-  });
-
-  it('Resolves wikilink referencing more than one note', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [{ slug: 'page-b' }],
-    });
-    const noteB1 = createTestNote({ uri: '/path/to/another/page-b.md' });
-    const noteB2 = createTestNote({ uri: '/path/to/more/page-b.md' });
-
-    const ws = createTestWorkspace();
-    ws.set(noteA)
-      .set(noteB1)
-      .set(noteB2);
-    const graph = FoamGraph.fromWorkspace(ws);
-
-    expect(graph.getLinks(noteA.uri)).toEqual([
-      {
-        source: noteA.uri,
-        target: noteB1.uri,
-        link: expect.objectContaining({ type: 'wikilink' }),
-      },
-    ]);
-  });
-
-  it('Resolves path wikilink in case of name conflict', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [{ slug: './more/page-b' }, { slug: 'yet/page-b' }],
-    });
-    const noteB1 = createTestNote({ uri: '/path/to/another/page-b.md' });
-    const noteB2 = createTestNote({ uri: '/path/to/more/page-b.md' });
-    const noteB3 = createTestNote({ uri: '/path/to/yet/page-b.md' });
-
-    const ws = createTestWorkspace();
-    ws.set(noteA)
-      .set(noteB1)
-      .set(noteB2)
-      .set(noteB3);
-    const graph = FoamGraph.fromWorkspace(ws);
-
-    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([
-      noteB2.uri,
-      noteB3.uri,
-    ]);
-  });
-
-  it('Supports attachments', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [
-        // wikilink with extension
-        { slug: 'attachment-a.pdf' },
-        // wikilink without extension
-        { slug: 'attachment-b' },
-      ],
-    });
-    const attachmentA = createTestNote({
-      uri: '/path/to/more/attachment-a.pdf',
-    });
-    const attachmentB = createTestNote({
-      uri: '/path/to/more/attachment-b.pdf',
-    });
-    const ws = createTestWorkspace();
-    ws.set(noteA)
-      .set(attachmentA)
-      .set(attachmentB);
-    const graph = FoamGraph.fromWorkspace(ws);
-
-    expect(graph.getBacklinks(attachmentA.uri).map(l => l.source)).toEqual([
-      noteA.uri,
-    ]);
-    // Attachments require extension
-    expect(graph.getBacklinks(attachmentB.uri).map(l => l.source)).toEqual([]);
-  });
-
-  it('Resolves conflicts alphabetically - part 1', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [{ slug: 'attachment-a.pdf' }],
-    });
-    const attachmentA = createTestNote({
-      uri: '/path/to/more/attachment-a.pdf',
-    });
-    const attachmentABis = createTestNote({
-      uri: '/path/to/attachment-a.pdf',
-    });
-    const ws = createTestWorkspace();
-    ws.set(noteA)
-      .set(attachmentA)
-      .set(attachmentABis);
-    const graph = FoamGraph.fromWorkspace(ws);
-
-    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([
-      attachmentABis.uri,
-    ]);
-  });
-
-  it('Resolves conflicts alphabetically - part 2', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [{ slug: 'attachment-a.pdf' }],
-    });
-    const attachmentA = createTestNote({
-      uri: '/path/to/more/attachment-a.pdf',
-    });
-    const attachmentABis = createTestNote({
-      uri: '/path/to/attachment-a.pdf',
-    });
-    const ws = createTestWorkspace();
-    ws.set(noteA)
-      .set(attachmentABis)
-      .set(attachmentA);
-    const graph = FoamGraph.fromWorkspace(ws);
-
-    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([
-      attachmentABis.uri,
-    ]);
-  });
-
-  it('Handles capitalization of files and wikilinks correctly', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [
-        // uppercased filename, lowercased slug
-        { slug: 'page-b' },
-        // lowercased filename, camelcased wikilink
-        { slug: 'Page-C' },
-        // lowercased filename, lowercased wikilink
-        { slug: 'page-d' },
-      ],
-    });
-    const ws = createTestWorkspace()
-      .set(noteA)
-      .set(createTestNote({ uri: '/somewhere/PAGE-B.md' }))
-      .set(createTestNote({ uri: '/path/another/page-c.md' }))
-      .set(createTestNote({ uri: '/path/another/page-d.md' }));
-    const graph = FoamGraph.fromWorkspace(ws);
-
-    expect(
-      graph
-        .getLinks(noteA.uri)
-        .map(link => link.target.path)
-        .sort()
-    ).toEqual([
-      '/path/another/page-c.md',
-      '/path/another/page-d.md',
-      '/somewhere/PAGE-B.md',
-    ]);
-  });
-});
-
-describe('Markdown direct links', () => {
-  it('Support absolute and relative path', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [{ to: './another/page-b.md' }, { to: 'more/page-c.md' }],
-    });
-    const noteB = createTestNote({
-      uri: '/path/to/another/page-b.md',
-      links: [{ to: '../../to/page-a.md' }],
-    });
-    const noteC = createTestNote({
-      uri: '/path/to/more/page-c.md',
-    });
-    const ws = createTestWorkspace();
-    ws.set(noteA)
       .set(noteB)
-      .set(noteC);
-    const graph = FoamGraph.fromWorkspace(ws);
-
+      .set(noteC)
+      .set(noteD);
+    expect(workspace.getIdentifier(noteABis.uri)).toEqual('another/note-a');
     expect(
-      graph
-        .getLinks(noteA.uri)
-        .map(link => link.target.path)
-        .sort()
-    ).toEqual(['/path/to/another/page-b.md', '/path/to/more/page-c.md']);
-
-    expect(graph.getLinks(noteB.uri).map(l => l.target)).toEqual([noteA.uri]);
-    expect(graph.getBacklinks(noteA.uri).map(l => l.source)).toEqual([
-      noteB.uri,
-    ]);
-    expect(graph.getConnections(noteA.uri)).toEqual([
-      {
-        source: noteA.uri,
-        target: noteB.uri,
-        link: expect.objectContaining({ type: 'link' }),
-      },
-      {
-        source: noteA.uri,
-        target: noteC.uri,
-        link: expect.objectContaining({ type: 'link' }),
-      },
-      {
-        source: noteB.uri,
-        target: noteA.uri,
-        link: expect.objectContaining({ type: 'link' }),
-      },
-    ]);
-  });
-});
-
-describe('Placeholders', () => {
-  it('Treats direct links to non-existing files as placeholders', () => {
-    const ws = createTestWorkspace();
-    const noteA = createTestNote({
-      uri: '/somewhere/from/page-a.md',
-      links: [{ to: '../page-b.md' }, { to: '/path/to/page-c.md' }],
-    });
-    ws.set(noteA);
-    const graph = FoamGraph.fromWorkspace(ws);
-
-    expect(graph.getAllConnections()[0]).toEqual({
-      source: noteA.uri,
-      target: URI.placeholder('/somewhere/page-b.md'),
-      link: expect.objectContaining({ type: 'link' }),
-    });
-    expect(graph.getAllConnections()[1]).toEqual({
-      source: noteA.uri,
-      target: URI.placeholder('/path/to/page-c.md'),
-      link: expect.objectContaining({ type: 'link' }),
-    });
-  });
-
-  it('Treats wikilinks without matching file as placeholders', () => {
-    const ws = createTestWorkspace();
-    const noteA = createTestNote({
-      uri: '/somewhere/page-a.md',
-      links: [{ slug: 'page-b' }],
-    });
-    ws.set(noteA);
-    const graph = FoamGraph.fromWorkspace(ws);
-
-    expect(graph.getAllConnections()[0]).toEqual({
-      source: noteA.uri,
-      target: URI.placeholder('page-b'),
-      link: expect.objectContaining({ type: 'wikilink' }),
-    });
-  });
-  it('Treats wikilink with definition to non-existing file as placeholders', () => {
-    const ws = createTestWorkspace();
-    const noteA = createTestNote({
-      uri: '/somewhere/page-a.md',
-      links: [{ slug: 'page-b' }, { slug: 'page-c' }],
-    });
-    noteA.definitions.push({
-      label: 'page-b',
-      url: './page-b.md',
-    });
-    noteA.definitions.push({
-      label: 'page-c',
-      url: '/path/to/page-c.md',
-    });
-    ws.set(noteA).set(
-      createTestNote({ uri: '/different/location/for/note-b.md' })
-    );
-    const graph = FoamGraph.fromWorkspace(ws);
-
-    expect(graph.getAllConnections()[0]).toEqual({
-      source: noteA.uri,
-      target: URI.placeholder('/somewhere/page-b.md'),
-      link: expect.objectContaining({ type: 'wikilink' }),
-    });
-    expect(graph.getAllConnections()[1]).toEqual({
-      source: noteA.uri,
-      target: URI.placeholder('/path/to/page-c.md'),
-      link: expect.objectContaining({ type: 'wikilink' }),
-    });
-  });
-
-  it('Should work with a placeholder named like a JS prototype property', () => {
-    const ws = createTestWorkspace();
-    const noteA = createTestNote({
-      uri: '/page-a.md',
-      links: [{ slug: 'constructor' }],
-    });
-    ws.set(noteA);
-    const graph = FoamGraph.fromWorkspace(ws);
-
-    expect(
-      graph
-        .getAllNodes()
-        .map(uri => uri.path)
-        .sort()
-    ).toEqual(['/page-a.md', 'constructor']);
-  });
-});
-
-describe('Updating workspace happy path', () => {
-  it('Update links when modifying note', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [{ slug: 'page-b' }],
-    });
-    const noteB = createTestNote({
-      uri: '/path/to/another/page-b.md',
-      links: [{ slug: 'page-c' }],
-    });
-    const noteC = createTestNote({
-      uri: '/path/to/more/page-c.md',
-    });
-    const ws = createTestWorkspace();
-    ws.set(noteA)
-      .set(noteB)
-      .set(noteC);
-    let graph = FoamGraph.fromWorkspace(ws);
-
-    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([noteB.uri]);
-    expect(graph.getBacklinks(noteB.uri).map(l => l.source)).toEqual([
-      noteA.uri,
-    ]);
-    expect(graph.getBacklinks(noteC.uri).map(l => l.source)).toEqual([
-      noteB.uri,
-    ]);
-
-    // update the note
-    const noteABis = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [{ slug: 'page-c' }],
-    });
-    ws.set(noteABis);
-    // change is not propagated immediately
-    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([noteB.uri]);
-    expect(graph.getBacklinks(noteB.uri).map(l => l.source)).toEqual([
-      noteA.uri,
-    ]);
-    expect(graph.getBacklinks(noteC.uri).map(l => l.source)).toEqual([
-      noteB.uri,
-    ]);
-
-    // recompute the links
-    graph = FoamGraph.fromWorkspace(ws);
-    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([noteC.uri]);
-    expect(graph.getBacklinks(noteB.uri).map(l => l.source)).toEqual([]);
-    expect(
-      graph
-        .getBacklinks(noteC.uri)
-        .map(link => link.source.path)
-        .sort()
-    ).toEqual(['/path/to/another/page-b.md', '/path/to/page-a.md']);
-  });
-
-  it('Removing target note should produce placeholder for wikilinks', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [{ slug: 'page-b' }],
-    });
-    const noteB = createTestNote({
-      uri: '/path/to/another/page-b.md',
-    });
-    const ws = createTestWorkspace();
-    ws.set(noteA).set(noteB);
-    const graph = FoamGraph.fromWorkspace(ws);
-
-    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([noteB.uri]);
-    expect(graph.getBacklinks(noteB.uri).map(l => l.source)).toEqual([
-      noteA.uri,
-    ]);
-    expect(ws.get(noteB.uri).type).toEqual('note');
-
-    // remove note-b
-    ws.delete(noteB.uri);
-    const graph2 = FoamGraph.fromWorkspace(ws);
-
-    expect(() => ws.get(noteB.uri)).toThrow();
-    expect(graph2.contains(URI.placeholder('page-b'))).toBeTruthy();
-  });
-
-  it('Adding note should replace placeholder for wikilinks', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [{ slug: 'page-b' }],
-    });
-    const ws = createTestWorkspace();
-    ws.set(noteA);
-    const graph = FoamGraph.fromWorkspace(ws);
-
-    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([
-      URI.placeholder('page-b'),
-    ]);
-    expect(graph.contains(URI.placeholder('page-b'))).toBeTruthy();
-
-    // add note-b
-    const noteB = createTestNote({
-      uri: '/path/to/another/page-b.md',
-    });
-
-    ws.set(noteB);
-    FoamGraph.fromWorkspace(ws);
-
-    expect(() => ws.get(URI.placeholder('page-b'))).toThrow();
-    expect(ws.get(noteB.uri).type).toEqual('note');
-  });
-
-  it('Removing target note should produce placeholder for direct links', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [{ to: '/path/to/another/page-b.md' }],
-    });
-    const noteB = createTestNote({
-      uri: '/path/to/another/page-b.md',
-    });
-    const ws = createTestWorkspace();
-    ws.set(noteA).set(noteB);
-    const graph = FoamGraph.fromWorkspace(ws);
-
-    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([noteB.uri]);
-    expect(graph.getBacklinks(noteB.uri).map(l => l.source)).toEqual([
-      noteA.uri,
-    ]);
-    expect(ws.get(noteB.uri).type).toEqual('note');
-
-    // remove note-b
-    ws.delete(noteB.uri);
-    const graph2 = FoamGraph.fromWorkspace(ws);
-
-    expect(() => ws.get(noteB.uri)).toThrow();
-    expect(
-      graph2.contains(URI.placeholder('/path/to/another/page-b.md'))
-    ).toBeTruthy();
-  });
-
-  it('Adding note should replace placeholder for direct links', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [{ to: '/path/to/another/page-b.md' }],
-    });
-    const ws = createTestWorkspace();
-    ws.set(noteA);
-    const graph = FoamGraph.fromWorkspace(ws);
-
-    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([
-      URI.placeholder('/path/to/another/page-b.md'),
-    ]);
-    expect(() =>
-      ws.get(URI.placeholder('/path/to/another/page-b.md'))
-    ).toThrow();
-
-    // add note-b
-    const noteB = createTestNote({
-      uri: '/path/to/another/page-b.md',
-    });
-
-    ws.set(noteB);
-    FoamGraph.fromWorkspace(ws);
-
-    expect(() => ws.get(URI.placeholder('page-b'))).toThrow();
-    expect(ws.get(noteB.uri).type).toEqual('note');
-  });
-
-  it('removing link to placeholder should remove placeholder', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [{ to: '/path/to/another/page-b.md' }],
-    });
-    const ws = createTestWorkspace().set(noteA);
-    const graph = FoamGraph.fromWorkspace(ws);
-    expect(
-      graph.contains(URI.placeholder('/path/to/another/page-b.md'))
-    ).toBeTruthy();
-
-    // update the note
-    const noteABis = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [],
-    });
-    ws.set(noteABis);
-    const graph2 = FoamGraph.fromWorkspace(ws);
-
-    expect(
-      graph2.contains(URI.placeholder('/path/to/another/page-b.md'))
-    ).toBeFalsy();
-  });
-});
-
-describe('Monitoring of workspace state', () => {
-  it('Update links when modifying note', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [{ slug: 'page-b' }],
-    });
-    const noteB = createTestNote({
-      uri: '/path/to/another/page-b.md',
-      links: [{ slug: 'page-c' }],
-    });
-    const noteC = createTestNote({
-      uri: '/path/to/more/page-c.md',
-    });
-    const ws = createTestWorkspace();
-    ws.set(noteA)
-      .set(noteB)
-      .set(noteC);
-    const graph = FoamGraph.fromWorkspace(ws, true);
-
-    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([noteB.uri]);
-    expect(graph.getBacklinks(noteB.uri).map(l => l.source)).toEqual([
-      noteA.uri,
-    ]);
-    expect(graph.getBacklinks(noteC.uri).map(l => l.source)).toEqual([
-      noteB.uri,
-    ]);
-
-    // update the note
-    const noteABis = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [{ slug: 'page-c' }],
-    });
-    ws.set(noteABis);
-
-    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([noteC.uri]);
-    expect(graph.getBacklinks(noteB.uri).map(l => l.source)).toEqual([]);
-    expect(
-      graph
-        .getBacklinks(noteC.uri)
-        .map(link => link.source.path)
-        .sort()
-    ).toEqual(['/path/to/another/page-b.md', '/path/to/page-a.md']);
-    ws.dispose();
-    graph.dispose();
-  });
-
-  it('Removing target note should produce placeholder for wikilinks', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [{ slug: 'page-b' }],
-    });
-    const noteB = createTestNote({
-      uri: '/path/to/another/page-b.md',
-    });
-    const ws = createTestWorkspace();
-    ws.set(noteA).set(noteB);
-    const graph = FoamGraph.fromWorkspace(ws, true);
-
-    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([noteB.uri]);
-    expect(graph.getBacklinks(noteB.uri).map(l => l.source)).toEqual([
-      noteA.uri,
-    ]);
-    expect(ws.get(noteB.uri).type).toEqual('note');
-
-    // remove note-b
-    ws.delete(noteB.uri);
-
-    expect(() => ws.get(noteB.uri)).toThrow();
-    ws.dispose();
-    graph.dispose();
-  });
-
-  it('Adding note should replace placeholder for wikilinks', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [{ slug: 'page-b' }],
-    });
-    const ws = createTestWorkspace();
-    ws.set(noteA);
-    const graph = FoamGraph.fromWorkspace(ws, true);
-
-    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([
-      URI.placeholder('page-b'),
-    ]);
-
-    // add note-b
-    const noteB = createTestNote({
-      uri: '/path/to/another/page-b.md',
-    });
-
-    ws.set(noteB);
-
-    expect(() => ws.get(URI.placeholder('page-b'))).toThrow();
-    expect(ws.get(noteB.uri).type).toEqual('note');
-    ws.dispose();
-    graph.dispose();
-  });
-
-  it('Removing target note should produce placeholder for direct links', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [{ to: '/path/to/another/page-b.md' }],
-    });
-    const noteB = createTestNote({
-      uri: '/path/to/another/page-b.md',
-    });
-    const ws = createTestWorkspace();
-    ws.set(noteA).set(noteB);
-    const graph = FoamGraph.fromWorkspace(ws, true);
-
-    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([noteB.uri]);
-    expect(graph.getBacklinks(noteB.uri).map(l => l.source)).toEqual([
-      noteA.uri,
-    ]);
-    expect(ws.get(noteB.uri).type).toEqual('note');
-
-    // remove note-b
-    ws.delete(noteB.uri);
-
-    expect(() => ws.get(noteB.uri)).toThrow();
-    expect(
-      graph.contains(URI.placeholder('/path/to/another/page-b.md'))
-    ).toBeTruthy();
-    ws.dispose();
-    graph.dispose();
-  });
-
-  it('Adding note should replace placeholder for direct links', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [{ to: '/path/to/another/page-b.md' }],
-    });
-    const ws = createTestWorkspace();
-    ws.set(noteA);
-    const graph = FoamGraph.fromWorkspace(ws, true);
-
-    expect(graph.getLinks(noteA.uri).map(l => l.target)).toEqual([
-      URI.placeholder('/path/to/another/page-b.md'),
-    ]);
-    expect(
-      graph.contains(URI.placeholder('/path/to/another/page-b.md'))
-    ).toBeTruthy();
-
-    // add note-b
-    const noteB = createTestNote({
-      uri: '/path/to/another/page-b.md',
-    });
-
-    ws.set(noteB);
-
-    expect(() => ws.get(URI.placeholder('page-b'))).toThrow();
-    expect(ws.get(noteB.uri).type).toEqual('note');
-    ws.dispose();
-    graph.dispose();
-  });
-
-  it('removing link to placeholder should remove placeholder', () => {
-    const noteA = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [{ to: '/path/to/another/page-b.md' }],
-    });
-    const ws = createTestWorkspace();
-    ws.set(noteA);
-    const graph = FoamGraph.fromWorkspace(ws, true);
-    expect(
-      graph.contains(URI.placeholder('/path/to/another/page-b.md'))
-    ).toBeTruthy();
-
-    // update the note
-    const noteABis = createTestNote({
-      uri: '/path/to/page-a.md',
-      links: [],
-    });
-    ws.set(noteABis);
-    expect(
-      graph.contains(URI.placeholder('/path/to/another/page-b.md'))
-    ).toBeFalsy();
-    ws.dispose();
-    graph.dispose();
+      workspace.getIdentifier(noteABis.uri, [noteB.uri, noteA.uri])
+    ).toEqual('note-a');
   });
 });

packages/foam-vscode/src/core/model/workspace.ts

@@ -19,7 +19,7 @@ export class FoamWorkspace implements IDisposable {
   /**
    * Resources by path
    */
-  private resources: Map<string, Resource> = new Map();
+  private _resources: Map<string, Resource> = new Map();
 
   registerProvider(provider: ResourceProvider) {
     this.providers.push(provider);
@@ -28,7 +28,7 @@ export class FoamWorkspace implements IDisposable {
 
   set(resource: Resource) {
     const old = this.find(resource.uri);
-    this.resources.set(normalize(resource.uri.path), resource);
+    this._resources.set(normalize(resource.uri.path), resource);
     isSome(old)
       ? this.onDidUpdateEmitter.fire({ old: old, new: resource })
       : this.onDidAddEmitter.fire(resource);
@@ -36,8 +36,8 @@ export class FoamWorkspace implements IDisposable {
   }
 
   delete(uri: URI) {
-    const deleted = this.resources.get(normalize(uri.path));
-    this.resources.delete(normalize(uri.path));
+    const deleted = this._resources.get(normalize(uri.path));
+    this._resources.delete(normalize(uri.path));
 
     isSome(deleted) && this.onDidDeleteEmitter.fire(deleted);
     return deleted ?? null;
@@ -48,7 +48,11 @@ export class FoamWorkspace implements IDisposable {
   }
 
   public list(): Resource[] {
-    return Array.from(this.resources.values());
+    return Array.from(this._resources.values());
+  }
+
+  public resources(): IterableIterator<Resource> {
+    return this._resources.values();
   }
 
   public get(uri: URI): Resource {
@@ -65,9 +69,9 @@ export class FoamWorkspace implements IDisposable {
     const mdNeedle =
       getExtension(needle) !== '.md' ? needle + '.md' : undefined;
     const resources = [];
-    for (const key of this.resources.keys()) {
+    for (const key of this._resources.keys()) {
       if ((mdNeedle && key.endsWith(mdNeedle)) || key.endsWith(needle)) {
-        resources.push(this.resources.get(normalize(key)));
+        resources.push(this._resources.get(normalize(key)));
       }
     }
     return resources.sort((a, b) => a.uri.path.localeCompare(b.uri.path));
@@ -78,17 +82,25 @@ export class FoamWorkspace implements IDisposable {
    *
    * @param forResource the resource to compute the identifier for
    */
-  public getIdentifier(forResource: URI): string {
+  public getIdentifier(forResource: URI, exclude?: URI[]): string {
     const amongst = [];
     const basename = forResource.getBasename();
-    for (const res of this.resources.values()) {
-      // Just a quick optimization to only add the elements that might match
-      if (res.uri.path.endsWith(basename)) {
-        if (!res.uri.isEqual(forResource)) {
-          amongst.push(res.uri);
-        }
+    for (const res of this._resources.values()) {
+      // skip elements that cannot possibly match
+      if (!res.uri.path.endsWith(basename)) {
+        continue;
       }
+      // skip self
+      if (res.uri.isEqual(forResource)) {
+        continue;
+      }
+      // skip exclude list
+      if (exclude && exclude.find(ex => ex.isEqual(res.uri))) {
+        continue;
+      }
+      amongst.push(res.uri);
     }
+
     let identifier = FoamWorkspace.getShortestIdentifier(
       forResource.path,
       amongst.map(uri => uri.path)
@@ -102,7 +114,7 @@ export class FoamWorkspace implements IDisposable {
 
   public find(reference: URI | string, baseUri?: URI): Resource | null {
     if (reference instanceof URI) {
-      return this.resources.get(normalize((reference as URI).path)) ?? null;
+      return this._resources.get(normalize((reference as URI).path)) ?? null;
     }
     let resource: Resource | null = null;
     const [path, fragment] = (reference as string).split('#');
@@ -112,11 +124,11 @@ export class FoamWorkspace implements IDisposable {
       if (isAbsolute(path) || isSome(baseUri)) {
         if (getExtension(path) !== '.md') {
           const uri = baseUri.resolve(path + '.md');
-          resource = uri ? this.resources.get(normalize(uri.path)) : null;
+          resource = uri ? this._resources.get(normalize(uri.path)) : null;
         }
         if (!resource) {
           const uri = baseUri.resolve(path);
-          resource = uri ? this.resources.get(normalize(uri.path)) : null;
+          resource = uri ? this._resources.get(normalize(uri.path)) : null;
         }
       }
     }
@@ -128,21 +140,32 @@ export class FoamWorkspace implements IDisposable {
 
   public resolveLink(resource: Resource, link: ResourceLink): URI {
     // TODO add tests
-    const provider = this.providers.find(p => p.supports(resource.uri));
-    return (
-      provider?.resolveLink(this, resource, link) ??
-      URI.placeholder(link.target)
+    for (const provider of this.providers) {
+      if (provider.supports(resource.uri)) {
+        return provider.resolveLink(this, resource, link);
+      }
+    }
+    throw new Error(
+      `Couldn't find provider for resource "${resource.uri.toString()}"`
     );
   }
 
   public read(uri: URI): Promise<string | null> {
-    const provider = this.providers.find(p => p.supports(uri));
-    return provider?.read(uri) ?? Promise.resolve(null);
+    for (const provider of this.providers) {
+      if (provider.supports(uri)) {
+        return provider.read(uri);
+      }
+    }
+    return Promise.resolve(null);
   }
 
   public readAsMarkdown(uri: URI): Promise<string | null> {
-    const provider = this.providers.find(p => p.supports(uri));
-    return provider?.readAsMarkdown(uri) ?? Promise.resolve(null);
+    for (const provider of this.providers) {
+      if (provider.supports(uri)) {
+        return provider.readAsMarkdown(uri);
+      }
+    }
+    return Promise.resolve(null);
   }
 
   public dispose(): void {

packages/foam-vscode/src/core/services/markdown-link.test.ts

@@ -0,0 +1,200 @@
+import { getRandomURI } from '../../test/test-utils';
+import { ResourceLink } from '../model/note';
+import { Range } from '../model/range';
+import { createMarkdownParser } from '../services/markdown-parser';
+import { MarkdownLink } from './markdown-link';
+
+describe('MarkdownLink', () => {
+  const parser = createMarkdownParser([]);
+  describe('parse wikilink', () => {
+    it('should parse target', () => {
+      const link = parser.parse(getRandomURI(), `this is a [[wikilink]]`)
+        .links[0];
+      const parsed = MarkdownLink.analyzeLink(link);
+      expect(parsed.target).toEqual('wikilink');
+      expect(parsed.section).toBeUndefined();
+      expect(parsed.alias).toBeUndefined();
+    });
+    it('should parse target and section', () => {
+      const link = parser.parse(
+        getRandomURI(),
+        `this is a [[wikilink#section]]`
+      ).links[0];
+      const parsed = MarkdownLink.analyzeLink(link);
+      expect(parsed.target).toEqual('wikilink');
+      expect(parsed.section).toEqual('section');
+      expect(parsed.alias).toBeUndefined();
+    });
+    it('should parse target and alias', () => {
+      const link = parser.parse(getRandomURI(), `this is a [[wikilink|alias]]`)
+        .links[0];
+      const parsed = MarkdownLink.analyzeLink(link);
+      expect(parsed.target).toEqual('wikilink');
+      expect(parsed.section).toBeUndefined();
+      expect(parsed.alias).toEqual('alias');
+    });
+    it('should parse target and alias with escaped separator', () => {
+      const link = parser.parse(
+        getRandomURI(),
+        `this is a [[wikilink\\|alias]]`
+      ).links[0];
+      const parsed = MarkdownLink.analyzeLink(link);
+      expect(parsed.target).toEqual('wikilink');
+      expect(parsed.section).toBeUndefined();
+      expect(parsed.alias).toEqual('alias');
+    });
+    it('should parse target section and alias', () => {
+      const link = parser.parse(
+        getRandomURI(),
+        `this is a [[wikilink with spaces#section with spaces|alias with spaces]]`
+      ).links[0];
+      const parsed = MarkdownLink.analyzeLink(link);
+      expect(parsed.target).toEqual('wikilink with spaces');
+      expect(parsed.section).toEqual('section with spaces');
+      expect(parsed.alias).toEqual('alias with spaces');
+    });
+    it('should parse section', () => {
+      const link = parser.parse(getRandomURI(), `this is a [[#section]]`)
+        .links[0];
+      const parsed = MarkdownLink.analyzeLink(link);
+      expect(parsed.target).toBeUndefined();
+      expect(parsed.section).toEqual('section');
+      expect(parsed.alias).toBeUndefined();
+    });
+  });
+
+  describe('parse direct link', () => {
+    it('should parse target', () => {
+      const link = parser.parse(getRandomURI(), `this is a [link](to/path.md)`)
+        .links[0];
+      const parsed = MarkdownLink.analyzeLink(link);
+      expect(parsed.target).toEqual('to/path.md');
+      expect(parsed.section).toBeUndefined();
+      expect(parsed.alias).toEqual('link');
+    });
+    it('should parse target and section', () => {
+      const link = parser.parse(
+        getRandomURI(),
+        `this is a [link](to/path.md#section)`
+      ).links[0];
+      const parsed = MarkdownLink.analyzeLink(link);
+      expect(parsed.target).toEqual('to/path.md');
+      expect(parsed.section).toEqual('section');
+      expect(parsed.alias).toEqual('link');
+    });
+    it('should parse section only', () => {
+      const link: ResourceLink = {
+        type: 'link',
+        rawText: '[link](#section)',
+        range: Range.create(0, 0),
+      };
+      const parsed = MarkdownLink.analyzeLink(link);
+      expect(parsed.target).toBeUndefined();
+      expect(parsed.section).toEqual('section');
+      expect(parsed.alias).toEqual('link');
+    });
+  });
+
+  describe('rename wikilink', () => {
+    it('should rename the target only', () => {
+      const link = parser.parse(
+        getRandomURI(),
+        `this is a [[wikilink#section]]`
+      ).links[0];
+      const edit = MarkdownLink.createUpdateLinkEdit(link, {
+        target: 'new-link',
+      });
+      expect(edit.newText).toEqual(`[[new-link#section]]`);
+      expect(edit.selection).toEqual(link.range);
+    });
+    it('should rename the section only', () => {
+      const link = parser.parse(
+        getRandomURI(),
+        `this is a [[wikilink#section]]`
+      ).links[0];
+      const edit = MarkdownLink.createUpdateLinkEdit(link, {
+        section: 'new-section',
+      });
+      expect(edit.newText).toEqual(`[[wikilink#new-section]]`);
+      expect(edit.selection).toEqual(link.range);
+    });
+    it('should rename both target and section', () => {
+      const link = parser.parse(
+        getRandomURI(),
+        `this is a [[wikilink#section]]`
+      ).links[0];
+      const edit = MarkdownLink.createUpdateLinkEdit(link, {
+        target: 'new-link',
+        section: 'new-section',
+      });
+      expect(edit.newText).toEqual(`[[new-link#new-section]]`);
+      expect(edit.selection).toEqual(link.range);
+    });
+    it('should be able to remove the section', () => {
+      const link = parser.parse(
+        getRandomURI(),
+        `this is a [[wikilink#section]]`
+      ).links[0];
+      const edit = MarkdownLink.createUpdateLinkEdit(link, {
+        section: '',
+      });
+      expect(edit.newText).toEqual(`[[wikilink]]`);
+      expect(edit.selection).toEqual(link.range);
+    });
+    it('should be able to rename the alias', () => {
+      const link = parser.parse(getRandomURI(), `this is a [[wikilink|alias]]`)
+        .links[0];
+      const edit = MarkdownLink.createUpdateLinkEdit(link, {
+        alias: 'new-alias',
+      });
+      expect(edit.newText).toEqual(`[[wikilink|new-alias]]`);
+      expect(edit.selection).toEqual(link.range);
+    });
+  });
+
+  describe('rename direct link', () => {
+    it('should rename the target only', () => {
+      const link = parser.parse(getRandomURI(), `this is a [link](to/path.md)`)
+        .links[0];
+      const edit = MarkdownLink.createUpdateLinkEdit(link, {
+        target: 'to/another-path.md',
+      });
+      expect(edit.newText).toEqual(`[link](to/another-path.md)`);
+      expect(edit.selection).toEqual(link.range);
+    });
+    it('should rename the section only', () => {
+      const link = parser.parse(
+        getRandomURI(),
+        `this is a [link](to/path.md#section)`
+      ).links[0];
+      const edit = MarkdownLink.createUpdateLinkEdit(link, {
+        section: 'section2',
+      });
+      expect(edit.newText).toEqual(`[link](to/path.md#section2)`);
+      expect(edit.selection).toEqual(link.range);
+    });
+    it('should rename both target and section', () => {
+      const link = parser.parse(
+        getRandomURI(),
+        `this is a [link](to/path.md#section)`
+      ).links[0];
+      const edit = MarkdownLink.createUpdateLinkEdit(link, {
+        target: 'to/another-path.md',
+        section: 'section2',
+      });
+      expect(edit.newText).toEqual(`[link](to/another-path.md#section2)`);
+      expect(edit.selection).toEqual(link.range);
+    });
+    it('should be able to remove the section', () => {
+      const link = parser.parse(
+        getRandomURI(),
+        `this is a [link](to/path.md#section)`
+      ).links[0];
+      const edit = MarkdownLink.createUpdateLinkEdit(link, {
+        section: '',
+      });
+      expect(edit.newText).toEqual(`[link](to/path.md)`);
+      expect(edit.selection).toEqual(link.range);
+    });
+  });
+});

packages/foam-vscode/src/core/services/markdown-link.ts

@@ -0,0 +1,57 @@
+import { ResourceLink } from '../model/note';
+
+export abstract class MarkdownLink {
+  private static wikilinkRegex = new RegExp(
+    /\[\[([^#|]+)?#?([^|]+)?\|?(.*)?\]\]/
+  );
+  private static directLinkRegex = new RegExp(
+    /\[([^\]]+)\]\(([^#]*)?#?([^\]]+)?\)/
+  );
+
+  public static analyzeLink(link: ResourceLink) {
+    if (link.type === 'wikilink') {
+      const [, target, section, alias] = this.wikilinkRegex.exec(link.rawText);
+      return {
+        target: target?.replace(/\\/g, ''),
+        section,
+        alias,
+      };
+    }
+    if (link.type === 'link') {
+      const [, alias, target, section] = this.directLinkRegex.exec(
+        link.rawText
+      );
+      return { target, section, alias };
+    }
+    throw new Error(
+      `Unexpected state: link of type ${link.type} is not supported`
+    );
+  }
+
+  public static createUpdateLinkEdit(
+    link: ResourceLink,
+    delta: { target?: string; section?: string; alias?: string }
+  ) {
+    const { target, section, alias } = MarkdownLink.analyzeLink(link);
+    const newTarget = delta.target ?? target;
+    const newSection = delta.section ?? section ?? '';
+    const newAlias = delta.alias ?? alias ?? '';
+    const sectionDivider = newSection ? '#' : '';
+    const aliasDivider = newAlias ? '|' : '';
+    if (link.type === 'wikilink') {
+      return {
+        newText: `[[${newTarget}${sectionDivider}${newSection}${aliasDivider}${newAlias}]]`,
+        selection: link.range,
+      };
+    }
+    if (link.type === 'link') {
+      return {
+        newText: `[${newAlias}](${newTarget}${sectionDivider}${newSection})`,
+        selection: link.range,
+      };
+    }
+    throw new Error(
+      `Unexpected state: link of type ${link.type} is not supported`
+    );
+  }
+}

packages/foam-vscode/src/core/services/markdown-parser.test.ts

@@ -0,0 +1,383 @@
+import { createMarkdownParser, ParserPlugin } from './markdown-parser';
+import { Logger } from '../utils/log';
+import { URI } from '../model/uri';
+import { Range } from '../model/range';
+import { getRandomURI } from '../../test/test-utils';
+
+Logger.setLevel('error');
+
+const parser = createMarkdownParser([]);
+const createNoteFromMarkdown = (content: string, path?: string) =>
+  parser.parse(path ? URI.file(path) : getRandomURI(), content);
+
+describe('Markdown parsing', () => {
+  it('should create a Resource from a markdown file', () => {
+    const note = createNoteFromMarkdown('Note content', '/a/path.md');
+    expect(note.uri).toEqual(URI.file('/a/path.md'));
+  });
+
+  describe('Links', () => {
+    it('should skip external links', () => {
+      const note = createNoteFromMarkdown(
+        `this is a [link to google](https://www.google.com)`
+      );
+      expect(note.links.length).toEqual(0);
+    });
+
+    it('should skip links to a section within the file', () => {
+      const note = createNoteFromMarkdown(
+        `this is a [link to intro](#introduction)`
+      );
+      expect(note.links.length).toEqual(0);
+    });
+
+    it('should detect regular markdown links', () => {
+      const note = createNoteFromMarkdown(
+        'this is a [link to page b](../doc/page-b.md)'
+      );
+      expect(note.links.length).toEqual(1);
+      const link = note.links[0];
+      expect(link.type).toEqual('link');
+      expect(link.rawText).toEqual('[link to page b](../doc/page-b.md)');
+    });
+
+    it('should detect links that have formatting in label', () => {
+      const note = createNoteFromMarkdown(
+        'this is [**link** with __formatting__](../doc/page-b.md)'
+      );
+      expect(note.links.length).toEqual(1);
+      const link = note.links[0];
+      expect(link.type).toEqual('link');
+    });
+
+    it('should detect wikilinks', () => {
+      const note = createNoteFromMarkdown(
+        'Some content and [[a link]] to [[a file]]'
+      );
+      expect(note.links.length).toEqual(2);
+      let link = note.links[0];
+      expect(link.type).toEqual('wikilink');
+      expect(link.rawText).toEqual('[[a link]]');
+      link = note.links[1];
+      expect(link.type).toEqual('wikilink');
+      expect(link.rawText).toEqual('[[a file]]');
+    });
+
+    it('should detect wikilinks that have aliases', () => {
+      const note = createNoteFromMarkdown(
+        'this is [[link|link alias]]. A link with spaces [[other link | spaced]]'
+      );
+      expect(note.links.length).toEqual(2);
+      let link = note.links[0];
+      expect(link.type).toEqual('wikilink');
+      expect(link.rawText).toEqual('[[link|link alias]]');
+      link = note.links[1];
+      expect(link.type).toEqual('wikilink');
+      expect(link.rawText).toEqual('[[other link | spaced]]');
+    });
+
+    it('should skip wikilinks in codeblocks', () => {
+      const noteA = createNoteFromMarkdown(`
+this is some text with our [[first-wikilink]].
+
+\`\`\`
+this is inside a [[codeblock]]
+\`\`\`
+
+this is some text with our [[second-wikilink]].
+    `);
+      expect(noteA.links.map(l => l.rawText)).toEqual([
+        '[[first-wikilink]]',
+        '[[second-wikilink]]',
+      ]);
+    });
+
+    it('should skip wikilinks in inlined codeblocks', () => {
+      const noteA = createNoteFromMarkdown(`
+this is some text with our [[first-wikilink]].
+
+this is \`inside a [[codeblock]]\`
+
+this is some text with our [[second-wikilink]].
+    `);
+      expect(noteA.links.map(l => l.rawText)).toEqual([
+        '[[first-wikilink]]',
+        '[[second-wikilink]]',
+      ]);
+    });
+  });
+
+  describe('Note Title', () => {
+    it('should initialize note title if heading exists', () => {
+      const note = createNoteFromMarkdown(`
+# Page A
+this note has a title
+    `);
+      expect(note.title).toBe('Page A');
+    });
+
+    it('should support wikilinks and urls in title', () => {
+      const note = createNoteFromMarkdown(`
+# Page A with [[wikilink]] and a [url](https://google.com)
+this note has a title
+    `);
+      expect(note.title).toBe('Page A with wikilink and a url');
+    });
+
+    it('should default to file name if heading does not exist', () => {
+      const note = createNoteFromMarkdown(
+        `This file has no heading.`,
+        '/page-d.md'
+      );
+
+      expect(note.title).toEqual('page-d');
+    });
+
+    it('should give precedence to frontmatter title over other headings', () => {
+      const note = createNoteFromMarkdown(`
+---
+title: Note Title
+date: 20-12-12
+---
+
+# Other Note Title
+    `);
+
+      expect(note.title).toBe('Note Title');
+    });
+
+    it('should support numbers as title', () => {
+      const note1 = createNoteFromMarkdown(`hello`, '/157.md');
+      expect(note1.title).toBe('157');
+
+      const note2 = createNoteFromMarkdown(`# 158`, '/157.md');
+      expect(note2.title).toBe('158');
+
+      const note3 = createNoteFromMarkdown(
+        `
+---
+title: 159
+---
+
+# 158
+`,
+        '/157.md'
+      );
+      expect(note3.title).toBe('159');
+    });
+
+    it('should support empty titles (see #276)', () => {
+      const note = createNoteFromMarkdown(
+        `
+#
+
+this note has an empty title line
+    `,
+        '/Hello Page.md'
+      );
+      expect(note.title).toEqual('Hello Page');
+    });
+  });
+
+  describe('Frontmatter', () => {
+    it('should parse yaml frontmatter', () => {
+      const note = createNoteFromMarkdown(`
+---
+title: Note Title
+date: 20-12-12
+---
+
+# Other Note Title`);
+
+      expect(note.properties.title).toBe('Note Title');
+      expect(note.properties.date).toBe('20-12-12');
+    });
+
+    it('should parse empty frontmatter', () => {
+      const note = createNoteFromMarkdown(`
+---
+---
+
+# Empty Frontmatter
+`);
+
+      expect(note.properties).toEqual({});
+    });
+
+    it('should not fail when there are issues with parsing frontmatter', () => {
+      const note = createNoteFromMarkdown(`
+---
+title: - one
+ - two
+ - #
+---
+
+`);
+
+      expect(note.properties).toEqual({});
+    });
+  });
+
+  describe('Tags', () => {
+    it('can find tags in the text of the note', () => {
+      const noteA = createNoteFromMarkdown(`
+# this is a #heading
+#this is some #text that includes #tags we #care-about.
+    `);
+      expect(noteA.tags).toEqual([
+        { label: 'heading', range: Range.create(1, 12, 1, 20) },
+        { label: 'this', range: Range.create(2, 0, 2, 5) },
+        { label: 'text', range: Range.create(2, 14, 2, 19) },
+        { label: 'tags', range: Range.create(2, 34, 2, 39) },
+        { label: 'care-about', range: Range.create(2, 43, 2, 54) },
+      ]);
+    });
+
+    it('will skip tags in codeblocks', () => {
+      const noteA = createNoteFromMarkdown(`
+this is some #text that includes #tags we #care-about.
+
+\`\`\`
+this is a #codeblock
+\`\`\`
+    `);
+      expect(noteA.tags.map(t => t.label)).toEqual([
+        'text',
+        'tags',
+        'care-about',
+      ]);
+    });
+
+    it('will skip tags in inlined codeblocks', () => {
+      const noteA = createNoteFromMarkdown(`
+this is some #text that includes #tags we #care-about.
+this is a \`inlined #codeblock\` `);
+      expect(noteA.tags.map(t => t.label)).toEqual([
+        'text',
+        'tags',
+        'care-about',
+      ]);
+    });
+    it('can find tags as text in yaml', () => {
+      const noteA = createNoteFromMarkdown(`
+---
+tags: hello, world  this_is_good
+---
+# this is a heading
+this is some #text that includes #tags we #care-about.
+    `);
+      expect(noteA.tags.map(t => t.label)).toEqual([
+        'hello',
+        'world',
+        'this_is_good',
+        'text',
+        'tags',
+        'care-about',
+      ]);
+    });
+
+    it('can find tags as array in yaml', () => {
+      const noteA = createNoteFromMarkdown(`
+---
+tags: [hello, world,  this_is_good]
+---
+# this is a heading
+this is some #text that includes #tags we #care-about.
+    `);
+      expect(noteA.tags.map(t => t.label)).toEqual([
+        'hello',
+        'world',
+        'this_is_good',
+        'text',
+        'tags',
+        'care-about',
+      ]);
+    });
+
+    it('provides rough range for tags in yaml', () => {
+      // For now it's enough to just get the YAML block range
+      // in the future we might want to be more specific
+
+      const noteA = createNoteFromMarkdown(`
+---
+tags: [hello, world, this_is_good]
+---
+# this is a heading
+this is some text
+    `);
+      expect(noteA.tags[0]).toEqual({
+        label: 'hello',
+        range: Range.create(1, 0, 3, 3),
+      });
+    });
+  });
+
+  describe('Sections', () => {
+    it('should find sections within the note', () => {
+      const note = createNoteFromMarkdown(`
+# Section 1
+
+This is the content of section 1.
+
+## Section 1.1
+
+This is the content of section 1.1.
+
+# Section 2
+
+This is the content of section 2.
+      `);
+      expect(note.sections).toHaveLength(3);
+      expect(note.sections[0].label).toEqual('Section 1');
+      expect(note.sections[0].range).toEqual(Range.create(1, 0, 9, 0));
+      expect(note.sections[1].label).toEqual('Section 1.1');
+      expect(note.sections[1].range).toEqual(Range.create(5, 0, 9, 0));
+      expect(note.sections[2].label).toEqual('Section 2');
+      expect(note.sections[2].range).toEqual(Range.create(9, 0, 13, 0));
+    });
+
+    it('should support wikilinks and links in the section label', () => {
+      const note = createNoteFromMarkdown(`
+# Section with [[wikilink]]
+
+This is the content of section with wikilink
+
+## Section with [url](https://google.com)
+
+This is the content of section with url`);
+      expect(note.sections).toHaveLength(2);
+      expect(note.sections[0].label).toEqual('Section with wikilink');
+      expect(note.sections[1].label).toEqual('Section with url');
+    });
+  });
+
+  describe('Parser plugins', () => {
+    const testPlugin: ParserPlugin = {
+      visit: (node, note) => {
+        if (node.type === 'heading') {
+          note.properties.hasHeading = true;
+        }
+      },
+    };
+    const parser = createMarkdownParser([testPlugin]);
+
+    it('can augment the parsing of the file', () => {
+      const note1 = parser.parse(
+        URI.file('/path/to/a'),
+        `
+This is a test note without headings.
+But with some content.
+`
+      );
+      expect(note1.properties.hasHeading).toBeUndefined();
+
+      const note2 = parser.parse(
+        URI.file('/path/to/a'),
+        `
+# This is a note with header
+and some content`
+      );
+      expect(note2.properties.hasHeading).toBeTruthy();
+    });
+  });
+});

packages/foam-vscode/src/core/services/markdown-parser.ts

@@ -8,24 +8,12 @@ import { parse as parseYAML } from 'yaml';
 import visit from 'unist-util-visit';
 import detectNewline from 'detect-newline';
 import os from 'os';
-import {
-  NoteLinkDefinition,
-  Resource,
-  ResourceLink,
-  WikiLink,
-  ResourceParser,
-} from './model/note';
-import { Position } from './model/position';
-import { Range } from './model/range';
-import { extractHashtags, extractTagsFromProp, isNone, isSome } from './utils';
-import { Logger } from './utils/log';
-import { URI } from './model/uri';
-import { FoamWorkspace } from './model/workspace';
-import { IDataStore, FileDataStore, IMatcher } from './services/datastore';
-import { IDisposable } from './common/lifecycle';
-import { ResourceProvider } from './model/provider';
-
-const ALIAS_DIVIDER_CHAR = '|';
+import { NoteLinkDefinition, Resource, ResourceParser } from '../model/note';
+import { Position } from '../model/position';
+import { Range } from '../model/range';
+import { extractHashtags, extractTagsFromProp, isSome } from '../utils';
+import { Logger } from '../utils/log';
+import { URI } from '../model/uri';
 
 export interface ParserPlugin {
   name?: string;
@@ -37,137 +25,116 @@ export interface ParserPlugin {
   onDidFindProperties?: (properties: any, note: Resource, node: Node) => void;
 }
 
-export class MarkdownResourceProvider implements ResourceProvider {
-  private disposables: IDisposable[] = [];
+const ALIAS_DIVIDER_CHAR = '|';
 
-  constructor(
-    private readonly matcher: IMatcher,
-    private readonly watcherInit?: (triggers: {
-      onDidChange: (uri: URI) => void;
-      onDidCreate: (uri: URI) => void;
-      onDidDelete: (uri: URI) => void;
-    }) => IDisposable[],
-    private readonly parser: ResourceParser = createMarkdownParser([]),
-    private readonly dataStore: IDataStore = new FileDataStore()
-  ) {}
+export function createMarkdownParser(
+  extraPlugins: ParserPlugin[]
+): ResourceParser {
+  const parser = unified()
+    .use(markdownParse, { gfm: true })
+    .use(frontmatterPlugin, ['yaml'])
+    .use(wikiLinkPlugin, { aliasDivider: ALIAS_DIVIDER_CHAR });
 
-  async init(workspace: FoamWorkspace) {
-    const filesByFolder = await Promise.all(
-      this.matcher.include.map(glob =>
-        this.dataStore.list(glob, this.matcher.exclude)
-      )
-    );
-    const files = this.matcher
-      .match(filesByFolder.flat())
-      .filter(this.supports);
+  const plugins = [
+    titlePlugin,
+    wikilinkPlugin,
+    definitionsPlugin,
+    tagsPlugin,
+    sectionsPlugin,
+    ...extraPlugins,
+  ];
 
-    await Promise.all(
-      files.map(async uri => {
-        Logger.info('Found: ' + uri.toString());
-        const content = await this.dataStore.read(uri);
-        if (isSome(content)) {
-          workspace.set(this.parser.parse(uri, content));
-        }
-      })
-    );
-
-    this.disposables =
-      this.watcherInit?.({
-        onDidChange: async uri => {
-          if (this.matcher.isMatch(uri) && this.supports(uri)) {
-            const content = await this.dataStore.read(uri);
-            isSome(content) &&
-              workspace.set(await this.parser.parse(uri, content));
-          }
-        },
-        onDidCreate: async uri => {
-          if (this.matcher.isMatch(uri) && this.supports(uri)) {
-            const content = await this.dataStore.read(uri);
-            isSome(content) &&
-              workspace.set(await this.parser.parse(uri, content));
-          }
-        },
-        onDidDelete: uri => {
-          this.supports(uri) && workspace.delete(uri);
-        },
-      }) ?? [];
-  }
-
-  supports(uri: URI) {
-    return uri.isMarkdown();
-  }
-
-  read(uri: URI): Promise<string | null> {
-    return this.dataStore.read(uri);
-  }
-
-  async readAsMarkdown(uri: URI): Promise<string | null> {
-    let content = await this.dataStore.read(uri);
-    if (isSome(content) && uri.fragment) {
-      const resource = this.parser.parse(uri, content);
-      const section = Resource.findSection(resource, uri.fragment);
-      if (isSome(section)) {
-        const rows = content.split('\n');
-        content = rows
-          .slice(section.range.start.line, section.range.end.line)
-          .join('\n');
-      }
+  for (const plugin of plugins) {
+    try {
+      plugin.onDidInitializeParser?.(parser);
+    } catch (e) {
+      handleError(plugin, 'onDidInitializeParser', undefined, e);
     }
-    return content;
   }
 
-  async fetch(uri: URI) {
-    const content = await this.read(uri);
-    return isSome(content) ? this.parser.parse(uri, content) : null;
-  }
+  const foamParser: ResourceParser = {
+    parse: (uri: URI, markdown: string): Resource => {
+      Logger.debug('Parsing:', uri.toString());
+      for (const plugin of plugins) {
+        try {
+          plugin.onWillParseMarkdown?.(markdown);
+        } catch (e) {
+          handleError(plugin, 'onWillParseMarkdown', uri, e);
+        }
+      }
+      const tree = parser.parse(markdown);
+      const eol = detectNewline(markdown) || os.EOL;
 
-  resolveLink(
-    workspace: FoamWorkspace,
-    resource: Resource,
-    link: ResourceLink
-  ) {
-    let targetUri: URI | undefined;
-    switch (link.type) {
-      case 'wikilink': {
-        const definitionUri = resource.definitions.find(
-          def => def.label === link.target
-        )?.url;
-        if (isSome(definitionUri)) {
-          const definedUri = resource.uri.resolve(definitionUri);
-          targetUri =
-            workspace.find(definedUri, resource.uri)?.uri ??
-            URI.placeholder(definedUri.path);
-        } else {
-          const [target, section] = link.target.split('#');
-          targetUri =
-            target === ''
-              ? resource.uri
-              : workspace.find(target, resource.uri)?.uri ??
-                URI.placeholder(link.target);
+      const note: Resource = {
+        uri: uri,
+        type: 'note',
+        properties: {},
+        title: '',
+        sections: [],
+        tags: [],
+        links: [],
+        definitions: [],
+        source: {
+          text: markdown,
+          contentStart: astPointToFoamPosition(tree.position!.start),
+          end: astPointToFoamPosition(tree.position!.end),
+          eol: eol,
+        },
+      };
 
-          if (section) {
-            targetUri = targetUri.withFragment(section);
+      for (const plugin of plugins) {
+        try {
+          plugin.onWillVisitTree?.(tree, note);
+        } catch (e) {
+          handleError(plugin, 'onWillVisitTree', uri, e);
+        }
+      }
+      visit(tree, node => {
+        if (node.type === 'yaml') {
+          try {
+            const yamlProperties = parseYAML((node as any).value) ?? {};
+            note.properties = {
+              ...note.properties,
+              ...yamlProperties,
+            };
+            // Update the start position of the note by exluding the metadata
+            note.source.contentStart = Position.create(
+              node.position!.end.line! + 2,
+              0
+            );
+
+            for (const plugin of plugins) {
+              try {
+                plugin.onDidFindProperties?.(yamlProperties, note, node);
+              } catch (e) {
+                handleError(plugin, 'onDidFindProperties', uri, e);
+              }
+            }
+          } catch (e) {
+            Logger.warn(`Error while parsing YAML for [${uri.toString()}]`, e);
           }
         }
-        break;
-      }
-      case 'link': {
-        const [target, section] = link.target.split('#');
-        targetUri =
-          workspace.find(target, resource.uri)?.uri ??
-          URI.placeholder(resource.uri.resolve(link.target).path);
-        if (section && !targetUri.isPlaceholder()) {
-          targetUri = targetUri.withFragment(section);
-        }
-        break;
-      }
-    }
-    return targetUri;
-  }
 
-  dispose() {
-    this.disposables.forEach(d => d.dispose());
-  }
+        for (const plugin of plugins) {
+          try {
+            plugin.visit?.(node, note, markdown);
+          } catch (e) {
+            handleError(plugin, 'visit', uri, e);
+          }
+        }
+      });
+      for (const plugin of plugins) {
+        try {
+          plugin.onDidVisitTree?.(tree, note);
+        } catch (e) {
+          handleError(plugin, 'onDidVisitTree', uri, e);
+        }
+      }
+      Logger.debug('Result:', note);
+      return note;
+    },
+  };
+  return foamParser;
 }
 
 /**
@@ -191,18 +158,18 @@ const tagsPlugin: ParserPlugin = {
   onDidFindProperties: (props, note, node) => {
     if (isSome(props.tags)) {
       const yamlTags = extractTagsFromProp(props.tags);
-      yamlTags.forEach(t => {
+      for (const tag of yamlTags) {
         note.tags.push({
-          label: t,
+          label: tag,
           range: astPositionToFoamRange(node.position!),
         });
-      });
+      }
     }
   },
   visit: (node, note) => {
     if (node.type === 'text') {
       const tags = extractHashtags((node as any).value);
-      tags.forEach(tag => {
+      for (const tag of tags) {
         const start = astPointToFoamPosition(node.position!.start);
         start.character = start.character + tag.offset;
         const end: Position = {
@@ -213,7 +180,7 @@ const tagsPlugin: ParserPlugin = {
           label: tag.label,
           range: Range.createFromPosition(start, end),
         });
-      });
+      }
     }
   },
 };
@@ -292,27 +259,14 @@ const wikilinkPlugin: ParserPlugin = {
   name: 'wikilink',
   visit: (node, note, noteSource) => {
     if (node.type === 'wikiLink') {
-      const text = (node as any).value;
-      const alias = node.data?.alias as string;
       const literalContent = noteSource.substring(
         node.position!.start.offset!,
         node.position!.end.offset!
       );
 
-      const hasAlias =
-        literalContent !== text && literalContent.includes(ALIAS_DIVIDER_CHAR);
       note.links.push({
         type: 'wikilink',
         rawText: literalContent,
-        label: hasAlias
-          ? alias.trim()
-          : literalContent.substring(2, literalContent.length - 2),
-        target: hasAlias
-          ? literalContent
-              .substring(2, literalContent.indexOf(ALIAS_DIVIDER_CHAR))
-              .replace(/\\/g, '')
-              .trim()
-          : text.trim(),
         range: astPositionToFoamRange(node.position!),
       });
     }
@@ -322,11 +276,13 @@ const wikilinkPlugin: ParserPlugin = {
       if (uri.scheme !== 'file' || uri.path === note.uri.path) {
         return;
       }
-      const label = getTextFromChildren(node);
+      const literalContent = noteSource.substring(
+        node.position!.start.offset!,
+        node.position!.end.offset!
+      );
       note.links.push({
         type: 'link',
-        target: targetUri,
-        label: label,
+        rawText: literalContent,
         range: astPositionToFoamRange(node.position!),
       });
     }
@@ -365,117 +321,6 @@ const handleError = (
   );
 };
 
-export function createMarkdownParser(
-  extraPlugins: ParserPlugin[]
-): ResourceParser {
-  const parser = unified()
-    .use(markdownParse, { gfm: true })
-    .use(frontmatterPlugin, ['yaml'])
-    .use(wikiLinkPlugin, { aliasDivider: ALIAS_DIVIDER_CHAR });
-
-  const plugins = [
-    titlePlugin,
-    wikilinkPlugin,
-    definitionsPlugin,
-    tagsPlugin,
-    sectionsPlugin,
-    ...extraPlugins,
-  ];
-
-  plugins.forEach(plugin => {
-    try {
-      plugin.onDidInitializeParser?.(parser);
-    } catch (e) {
-      handleError(plugin, 'onDidInitializeParser', undefined, e);
-    }
-  });
-
-  const foamParser: ResourceParser = {
-    parse: (uri: URI, markdown: string): Resource => {
-      Logger.debug('Parsing:', uri.toString());
-      markdown = plugins.reduce((acc, plugin) => {
-        try {
-          return plugin.onWillParseMarkdown?.(acc) || acc;
-        } catch (e) {
-          handleError(plugin, 'onWillParseMarkdown', uri, e);
-          return acc;
-        }
-      }, markdown);
-      const tree = parser.parse(markdown);
-      const eol = detectNewline(markdown) || os.EOL;
-
-      const note: Resource = {
-        uri: uri,
-        type: 'note',
-        properties: {},
-        title: '',
-        sections: [],
-        tags: [],
-        links: [],
-        definitions: [],
-        source: {
-          text: markdown,
-          contentStart: astPointToFoamPosition(tree.position!.start),
-          end: astPointToFoamPosition(tree.position!.end),
-          eol: eol,
-        },
-      };
-
-      plugins.forEach(plugin => {
-        try {
-          plugin.onWillVisitTree?.(tree, note);
-        } catch (e) {
-          handleError(plugin, 'onWillVisitTree', uri, e);
-        }
-      });
-      visit(tree, node => {
-        if (node.type === 'yaml') {
-          try {
-            const yamlProperties = parseYAML((node as any).value) ?? {};
-            note.properties = {
-              ...note.properties,
-              ...yamlProperties,
-            };
-            // Update the start position of the note by exluding the metadata
-            note.source.contentStart = Position.create(
-              node.position!.end.line! + 2,
-              0
-            );
-
-            for (let i = 0, len = plugins.length; i < len; i++) {
-              try {
-                plugins[i].onDidFindProperties?.(yamlProperties, note, node);
-              } catch (e) {
-                handleError(plugins[i], 'onDidFindProperties', uri, e);
-              }
-            }
-          } catch (e) {
-            Logger.warn(`Error while parsing YAML for [${uri.toString()}]`, e);
-          }
-        }
-
-        for (let i = 0, len = plugins.length; i < len; i++) {
-          try {
-            plugins[i].visit?.(node, note, markdown);
-          } catch (e) {
-            handleError(plugins[i], 'visit', uri, e);
-          }
-        }
-      });
-      plugins.forEach(plugin => {
-        try {
-          plugin.onDidVisitTree?.(tree, note);
-        } catch (e) {
-          handleError(plugin, 'onDidVisitTree', uri, e);
-        }
-      });
-      Logger.debug('Result:', note);
-      return note;
-    },
-  };
-  return foamParser;
-}
-
 function getFoamDefinitions(
   defs: NoteLinkDefinition[],
   fileEndPoint: Position
@@ -501,68 +346,6 @@ function getFoamDefinitions(
   return foamDefinitions;
 }
 
-export function stringifyMarkdownLinkReferenceDefinition(
-  definition: NoteLinkDefinition
-) {
-  const url =
-    definition.url.indexOf(' ') > 0 ? `<${definition.url}>` : definition.url;
-  let text = `[${definition.label}]: ${url}`;
-  if (definition.title) {
-    text = `${text} "${definition.title}"`;
-  }
-
-  return text;
-}
-export function createMarkdownReferences(
-  workspace: FoamWorkspace,
-  noteUri: URI,
-  includeExtension: boolean
-): NoteLinkDefinition[] {
-  const source = workspace.find(noteUri);
-  // Should never occur since we're already in a file,
-  if (source?.type !== 'note') {
-    console.warn(
-      `Note ${noteUri.toString()} note found in workspace when attempting \
-to generate markdown reference list`
-    );
-    return [];
-  }
-
-  return source.links
-    .filter(isWikilink)
-    .map(link => {
-      const targetUri = workspace.resolveLink(source, link);
-      const target = workspace.find(targetUri);
-      if (isNone(target)) {
-        Logger.warn(
-          `Link ${targetUri.toString()} in ${noteUri.toString()} is not valid.`
-        );
-        return null;
-      }
-      if (target.type === 'placeholder') {
-        // no need to create definitions for placeholders
-        return null;
-      }
-
-      let relativeUri = target.uri.relativeTo(noteUri.getDirectory());
-      if (!includeExtension) {
-        relativeUri = relativeUri.changeExtension('*', '');
-      }
-
-      // [wikilink-text]: path/to/file.md "Page title"
-      return {
-        label:
-          link.rawText.indexOf('[[') > -1
-            ? link.rawText.substring(2, link.rawText.length - 2)
-            : link.rawText || link.label,
-        url: relativeUri.path,
-        title: target.title,
-      };
-    })
-    .filter(isSome)
-    .sort();
-}
-
 /**
  * Converts the 1-index Point object into the VS Code 0-index Position object
  * @param point ast Point (1-indexed)
@@ -584,7 +367,3 @@ const astPositionToFoamRange = (pos: AstPosition): Range =>
     pos.end.line - 1,
     pos.end.column - 1
   );
-
-const isWikilink = (link: ResourceLink): link is WikiLink => {
-  return link.type === 'wikilink';
-};

packages/foam-vscode/src/core/services/markdown-provider.test.ts

@@ -0,0 +1,259 @@
+import { createMarkdownParser } from './markdown-parser';
+import { createMarkdownReferences } from './markdown-provider';
+import { Logger } from '../utils/log';
+import { URI } from '../model/uri';
+import {
+  createTestNote,
+  createTestWorkspace,
+  getRandomURI,
+} from '../../test/test-utils';
+
+Logger.setLevel('error');
+
+const parser = createMarkdownParser([]);
+const createNoteFromMarkdown = (content: string, path?: string) =>
+  parser.parse(path ? URI.file(path) : getRandomURI(), content);
+
+describe('Link resolution', () => {
+  describe('Wikilinks', () => {
+    it('should resolve basename wikilinks with files in same directory', () => {
+      const workspace = createTestWorkspace();
+      const noteA = createNoteFromMarkdown('Link to [[page b]]', './page-a.md');
+      const noteB = createNoteFromMarkdown('Content of page b', './page b.md');
+      workspace.set(noteA).set(noteB);
+      expect(workspace.resolveLink(noteA, noteA.links[0])).toEqual(noteB.uri);
+    });
+
+    it('should resolve basename wikilinks with files in other directory', () => {
+      const workspace = createTestWorkspace();
+      const noteA = createNoteFromMarkdown('Link to [[page b]]', './page-a.md');
+      const noteB = createNoteFromMarkdown('Page b', './folder/page b.md');
+      workspace.set(noteA).set(noteB);
+      expect(workspace.resolveLink(noteA, noteA.links[0])).toEqual(noteB.uri);
+    });
+
+    it('should resolve wikilinks that represent an absolute path', () => {
+      const workspace = createTestWorkspace();
+      const noteA = createNoteFromMarkdown(
+        'Link to [[/folder/page b]]',
+        '/page-a.md'
+      );
+      const noteB = createNoteFromMarkdown('Page b', '/folder/page b.md');
+      workspace.set(noteA).set(noteB);
+      expect(workspace.resolveLink(noteA, noteA.links[0])).toEqual(noteB.uri);
+    });
+
+    it('should resolve wikilinks that represent a relative path', () => {
+      const workspace = createTestWorkspace();
+      const noteA = createNoteFromMarkdown(
+        'Link to [[../two/page b]]',
+        '/path/one/page-a.md'
+      );
+      const noteB = createNoteFromMarkdown('Page b', '/path/one/page b.md');
+      const noteB2 = createNoteFromMarkdown('Page b 2', '/path/two/page b.md');
+      workspace
+        .set(noteA)
+        .set(noteB)
+        .set(noteB2);
+      expect(workspace.resolveLink(noteA, noteA.links[0])).toEqual(noteB2.uri);
+    });
+
+    it('should resolve ambiguous wikilinks', () => {
+      const workspace = createTestWorkspace();
+      const noteA = createNoteFromMarkdown('Link to [[page b]]', '/page-a.md');
+      const noteB = createNoteFromMarkdown('Page b', '/path/one/page b.md');
+      const noteB2 = createNoteFromMarkdown('Page b2', '/path/two/page b.md');
+      workspace
+        .set(noteA)
+        .set(noteB)
+        .set(noteB2);
+      expect(workspace.resolveLink(noteA, noteA.links[0])).toEqual(noteB.uri);
+    });
+
+    it('should resolve path wikilink even with other ambiguous notes', () => {
+      const noteA = createTestNote({
+        uri: '/path/to/page-a.md',
+        links: [{ slug: './more/page-b' }, { slug: 'yet/page-b' }],
+      });
+      const noteB1 = createTestNote({ uri: '/path/to/another/page-b.md' });
+      const noteB2 = createTestNote({ uri: '/path/to/more/page-b.md' });
+      const noteB3 = createTestNote({ uri: '/path/to/yet/page-b.md' });
+
+      const ws = createTestWorkspace();
+      ws.set(noteA)
+        .set(noteB1)
+        .set(noteB2)
+        .set(noteB3);
+
+      expect(ws.resolveLink(noteA, noteA.links[0])).toEqual(noteB2.uri);
+      expect(ws.resolveLink(noteA, noteA.links[1])).toEqual(noteB3.uri);
+    });
+
+    it('should resolve Foam wikilinks', () => {
+      const workspace = createTestWorkspace();
+      const noteA = createNoteFromMarkdown(
+        'Link to [[two/page b]] and [[one/page b]]',
+        '/page-a.md'
+      );
+      const noteB = createNoteFromMarkdown('Page b', '/path/one/page b.md');
+      const noteB2 = createNoteFromMarkdown('Page b2', '/path/two/page b.md');
+      workspace
+        .set(noteA)
+        .set(noteB)
+        .set(noteB2);
+      expect(workspace.resolveLink(noteA, noteA.links[0])).toEqual(noteB2.uri);
+      expect(workspace.resolveLink(noteA, noteA.links[1])).toEqual(noteB.uri);
+    });
+
+    it('should use wikilink definitions when available to resolve target', () => {
+      const ws = createTestWorkspace();
+      const noteA = createTestNote({
+        uri: '/somewhere/from/page-a.md',
+        links: [{ slug: 'page-b' }],
+      });
+      noteA.definitions.push({
+        label: 'page-b',
+        url: '../to/page-b.md',
+      });
+      const noteB = createTestNote({
+        uri: '/somewhere/to/page-b.md',
+      });
+      ws.set(noteA).set(noteB);
+      expect(ws.resolveLink(noteA, noteA.links[0])).toEqual(noteB.uri);
+    });
+
+    it('should support case insensitive wikilink resolution', () => {
+      const noteA = createTestNote({
+        uri: '/path/to/page-a.md',
+        links: [
+          // uppercased filename, lowercased slug
+          { slug: 'page-b' },
+          // lowercased filename, camelcased wikilink
+          { slug: 'Page-C' },
+          // lowercased filename, lowercased wikilink
+          { slug: 'page-d' },
+        ],
+      });
+      const noteB = createTestNote({ uri: '/somewhere/PAGE-B.md' });
+      const noteC = createTestNote({ uri: '/path/another/page-c.md' });
+      const noteD = createTestNote({ uri: '/path/another/page-d.md' });
+      const ws = createTestWorkspace()
+        .set(noteA)
+        .set(noteB)
+        .set(noteC)
+        .set(noteD);
+
+      expect(ws.resolveLink(noteA, noteA.links[0])).toEqual(noteB.uri);
+      expect(ws.resolveLink(noteA, noteA.links[1])).toEqual(noteC.uri);
+      expect(ws.resolveLink(noteA, noteA.links[2])).toEqual(noteD.uri);
+    });
+  });
+
+  describe('Markdown direct links', () => {
+    it('should support absolute path 1', () => {
+      const noteA = createTestNote({
+        uri: '/path/to/page-a.md',
+        links: [{ to: '/path/to/another/page-b.md' }],
+      });
+      const noteB = createTestNote({
+        uri: '/path/to/another/page-b.md',
+        links: [{ to: '../../to/page-a.md' }],
+      });
+
+      const ws = createTestWorkspace();
+      ws.set(noteA).set(noteB);
+      expect(ws.resolveLink(noteA, noteA.links[0])).toEqual(noteB.uri);
+    });
+
+    it('should support relative path 1', () => {
+      const noteA = createTestNote({
+        uri: '/path/to/page-a.md',
+        links: [{ to: './another/page-b.md' }],
+      });
+      const noteB = createTestNote({
+        uri: '/path/to/another/page-b.md',
+        links: [{ to: '../../to/page-a.md' }],
+      });
+
+      const ws = createTestWorkspace();
+      ws.set(noteA).set(noteB);
+      expect(ws.resolveLink(noteA, noteA.links[0])).toEqual(noteB.uri);
+    });
+
+    it('should support relative path 2', () => {
+      const noteA = createTestNote({
+        uri: '/path/to/page-a.md',
+        links: [{ to: 'more/page-b.md' }],
+      });
+      const noteB = createTestNote({
+        uri: '/path/to/more/page-b.md',
+      });
+      const ws = createTestWorkspace();
+      ws.set(noteA).set(noteB);
+      expect(ws.resolveLink(noteA, noteA.links[0])).toEqual(noteB.uri);
+    });
+
+    it('should default to relative path', () => {
+      const noteA = createTestNote({
+        uri: '/path/to/page-a.md',
+        links: [{ to: 'page .md' }],
+      });
+      const noteB = createTestNote({
+        uri: '/path/to/page .md',
+      });
+      const ws = createTestWorkspace();
+      ws.set(noteA).set(noteB);
+      expect(ws.resolveLink(noteA, noteA.links[0])).toEqual(noteB.uri);
+    });
+  });
+});
+
+describe('Generation of markdown references', () => {
+  it('should generate links without file extension when includeExtension = false', () => {
+    const workspace = createTestWorkspace();
+    const noteA = createNoteFromMarkdown(
+      'Link to [[page-b]] and [[page-c]]',
+      '/dir1/page-a.md'
+    );
+    workspace
+      .set(noteA)
+      .set(createNoteFromMarkdown('Content of note B', '/dir1/page-b.md'))
+      .set(createNoteFromMarkdown('Content of note C', '/dir1/page-c.md'));
+
+    const references = createMarkdownReferences(workspace, noteA.uri, false);
+    expect(references.map(r => r.url)).toEqual(['page-b', 'page-c']);
+  });
+
+  it('should generate links with file extension when includeExtension = true', () => {
+    const workspace = createTestWorkspace();
+    const noteA = createNoteFromMarkdown(
+      'Link to [[page-b]] and [[page-c]]',
+      '/dir1/page-a.md'
+    );
+    workspace
+      .set(noteA)
+      .set(createNoteFromMarkdown('Content of note B', '/dir1/page-b.md'))
+      .set(createNoteFromMarkdown('Content of note C', '/dir1/page-c.md'));
+
+    const references = createMarkdownReferences(workspace, noteA.uri, true);
+    expect(references.map(r => r.url)).toEqual(['page-b.md', 'page-c.md']);
+  });
+
+  it('should use relative paths', () => {
+    const workspace = createTestWorkspace();
+    const noteA = createNoteFromMarkdown(
+      'Link to [[page-b]] and [[page-c]]',
+      '/dir1/page-a.md'
+    );
+    workspace
+      .set(noteA)
+      .set(createNoteFromMarkdown('Content of note B', '/dir2/page-b.md'))
+      .set(createNoteFromMarkdown('Content of note C', '/dir3/page-c.md'));
+
+    const references = createMarkdownReferences(workspace, noteA.uri, true);
+    expect(references.map(r => r.url)).toEqual([
+      '../dir2/page-b.md',
+      '../dir3/page-c.md',
+    ]);
+  });
+});

packages/foam-vscode/src/core/services/markdown-provider.ts

@@ -0,0 +1,214 @@
+import {
+  NoteLinkDefinition,
+  Resource,
+  ResourceLink,
+  ResourceParser,
+} from '../model/note';
+import { isNone, isSome } from '../utils';
+import { Logger } from '../utils/log';
+import { URI } from '../model/uri';
+import { FoamWorkspace } from '../model/workspace';
+import { IDataStore, FileDataStore, IMatcher } from '../services/datastore';
+import { IDisposable } from '../common/lifecycle';
+import { ResourceProvider } from '../model/provider';
+import { createMarkdownParser } from './markdown-parser';
+import { MarkdownLink } from './markdown-link';
+
+export class MarkdownResourceProvider implements ResourceProvider {
+  private disposables: IDisposable[] = [];
+
+  constructor(
+    private readonly matcher: IMatcher,
+    private readonly watcherInit?: (triggers: {
+      onDidChange: (uri: URI) => void;
+      onDidCreate: (uri: URI) => void;
+      onDidDelete: (uri: URI) => void;
+    }) => IDisposable[],
+    private readonly parser: ResourceParser = createMarkdownParser([]),
+    private readonly dataStore: IDataStore = new FileDataStore()
+  ) {}
+
+  async init(workspace: FoamWorkspace) {
+    const filesByFolder = await Promise.all(
+      this.matcher.include.map(glob =>
+        this.dataStore.list(glob, this.matcher.exclude)
+      )
+    );
+    const files = this.matcher
+      .match(filesByFolder.flat())
+      .filter(this.supports);
+
+    await Promise.all(
+      files.map(async uri => {
+        Logger.info('Found: ' + uri.toString());
+        const content = await this.dataStore.read(uri);
+        if (isSome(content)) {
+          workspace.set(this.parser.parse(uri, content));
+        }
+      })
+    );
+
+    this.disposables =
+      this.watcherInit?.({
+        onDidChange: async uri => {
+          if (this.matcher.isMatch(uri) && this.supports(uri)) {
+            const content = await this.dataStore.read(uri);
+            isSome(content) &&
+              workspace.set(await this.parser.parse(uri, content));
+          }
+        },
+        onDidCreate: async uri => {
+          if (this.matcher.isMatch(uri) && this.supports(uri)) {
+            const content = await this.dataStore.read(uri);
+            isSome(content) &&
+              workspace.set(await this.parser.parse(uri, content));
+          }
+        },
+        onDidDelete: uri => {
+          this.supports(uri) && workspace.delete(uri);
+        },
+      }) ?? [];
+  }
+
+  supports(uri: URI) {
+    return uri.isMarkdown();
+  }
+
+  read(uri: URI): Promise<string | null> {
+    return this.dataStore.read(uri);
+  }
+
+  async readAsMarkdown(uri: URI): Promise<string | null> {
+    let content = await this.dataStore.read(uri);
+    if (isSome(content) && uri.fragment) {
+      const resource = this.parser.parse(uri, content);
+      const section = Resource.findSection(resource, uri.fragment);
+      if (isSome(section)) {
+        const rows = content.split('\n');
+        content = rows
+          .slice(section.range.start.line, section.range.end.line)
+          .join('\n');
+      }
+    }
+    return content;
+  }
+
+  async fetch(uri: URI) {
+    const content = await this.read(uri);
+    return isSome(content) ? this.parser.parse(uri, content) : null;
+  }
+
+  resolveLink(
+    workspace: FoamWorkspace,
+    resource: Resource,
+    link: ResourceLink
+  ) {
+    let targetUri: URI | undefined;
+    const { target, section } = MarkdownLink.analyzeLink(link);
+    switch (link.type) {
+      case 'wikilink': {
+        let definitionUri = undefined;
+        for (const def of resource.definitions) {
+          if (def.label === target) {
+            definitionUri = def.url;
+            break;
+          }
+        }
+        if (isSome(definitionUri)) {
+          const definedUri = resource.uri.resolve(definitionUri);
+          targetUri =
+            workspace.find(definedUri, resource.uri)?.uri ??
+            URI.placeholder(definedUri.path);
+        } else {
+          targetUri =
+            target === ''
+              ? resource.uri
+              : workspace.find(target, resource.uri)?.uri ??
+                URI.placeholder(target);
+
+          if (section) {
+            targetUri = targetUri.withFragment(section);
+          }
+        }
+        break;
+      }
+      case 'link': {
+        targetUri =
+          workspace.find(target, resource.uri)?.uri ??
+          URI.placeholder(resource.uri.resolve(target).path);
+        if (section && !targetUri.isPlaceholder()) {
+          targetUri = targetUri.withFragment(section);
+        }
+        break;
+      }
+    }
+    return targetUri;
+  }
+
+  dispose() {
+    this.disposables.forEach(d => d.dispose());
+  }
+}
+
+export function createMarkdownReferences(
+  workspace: FoamWorkspace,
+  noteUri: URI,
+  includeExtension: boolean
+): NoteLinkDefinition[] {
+  const source = workspace.find(noteUri);
+  // Should never occur since we're already in a file,
+  if (source?.type !== 'note') {
+    console.warn(
+      `Note ${noteUri.toString()} note found in workspace when attempting \
+to generate markdown reference list`
+    );
+    return [];
+  }
+
+  return source.links
+    .filter(link => link.type === 'wikilink')
+    .map(link => {
+      const targetUri = workspace.resolveLink(source, link);
+      const target = workspace.find(targetUri);
+      if (isNone(target)) {
+        Logger.warn(
+          `Link ${targetUri.toString()} in ${noteUri.toString()} is not valid.`
+        );
+        return null;
+      }
+      if (target.type === 'placeholder') {
+        // no need to create definitions for placeholders
+        return null;
+      }
+
+      let relativeUri = target.uri.relativeTo(noteUri.getDirectory());
+      if (!includeExtension) {
+        relativeUri = relativeUri.changeExtension('*', '');
+      }
+
+      // [wikilink-text]: path/to/file.md "Page title"
+      return {
+        label:
+          link.rawText.indexOf('[[') > -1
+            ? link.rawText.substring(2, link.rawText.length - 2)
+            : link.rawText,
+        url: relativeUri.path,
+        title: target.title,
+      };
+    })
+    .filter(isSome)
+    .sort();
+}
+
+export function stringifyMarkdownLinkReferenceDefinition(
+  definition: NoteLinkDefinition
+) {
+  const url =
+    definition.url.indexOf(' ') > 0 ? `<${definition.url}>` : definition.url;
+  let text = `[${definition.label}]: ${url}`;
+  if (definition.title) {
+    text = `${text} "${definition.title}"`;
+  }
+
+  return text;
+}

packages/foam-vscode/src/extension.ts

@@ -1,5 +1,5 @@
 import { workspace, ExtensionContext, window } from 'vscode';
-import { MarkdownResourceProvider } from './core/markdown-provider';
+import { MarkdownResourceProvider } from './core/services/markdown-provider';
 import { bootstrap } from './core/model/foam';
 import { FileDataStore, Matcher } from './core/services/datastore';
 import { Logger } from './core/utils/log';

packages/foam-vscode/src/features/backlinks.spec.ts

@@ -37,7 +37,7 @@ describe('Backlinks panel', () => {
   const noteB = createTestNote({
     root: rootUri,
     uri: './note-b.md',
-    links: [{ slug: 'note-a' }, { slug: 'note-a' }],
+    links: [{ slug: 'note-a' }, { slug: 'note-a#section' }],
   });
   const noteC = createTestNote({
     root: rootUri,

packages/foam-vscode/src/features/backlinks.ts

@@ -30,9 +30,7 @@ const feature: FoamFeature = {
 
     context.subscriptions.push(
       vscode.window.registerTreeDataProvider('foam-vscode.backlinks', provider),
-      foam.workspace.onDidAdd(() => provider.refresh()),
-      foam.workspace.onDidUpdate(() => provider.refresh()),
-      foam.workspace.onDidDelete(() => provider.refresh())
+      foam.graph.onDidUpdate(() => provider.refresh())
     );
   },
 };
@@ -63,7 +61,10 @@ export class BacklinksTreeDataProvider
       const backlinkRefs = Promise.all(
         resource.links
           .filter(link =>
-            this.workspace.resolveLink(resource, link).isEqual(uri)
+            this.workspace
+              .resolveLink(resource, link)
+              .asPlain()
+              .isEqual(uri)
           )
           .map(async link => {
             const item = new BacklinkTreeItem(resource, link);
@@ -93,7 +94,9 @@ export class BacklinksTreeDataProvider
     }
 
     const backlinksByResourcePath = groupBy(
-      this.graph.getConnections(uri).filter(c => c.target.isEqual(uri)),
+      this.graph
+        .getConnections(uri)
+        .filter(c => c.target.asPlain().isEqual(uri)),
       b => b.source.path
     );
 
@@ -126,7 +129,7 @@ export class BacklinkTreeItem extends vscode.TreeItem {
     public readonly resource: Resource,
     public readonly link: ResourceLink
   ) {
-    super(link.label, vscode.TreeItemCollapsibleState.None);
+    super(link.rawText, vscode.TreeItemCollapsibleState.None);
     this.label = `${link.range.start.line}: ${this.label}`;
     this.command = {
       command: 'vscode.open',

packages/foam-vscode/src/features/copy-without-brackets.spec.ts

@@ -1,9 +1,5 @@
 import { env, Position, Selection, commands } from 'vscode';
-import {
-  createFile,
-  getUriInWorkspace,
-  showInEditor,
-} from '../test/test-utils-vscode';
+import { createFile, showInEditor } from '../test/test-utils-vscode';
 
 describe('copyWithoutBrackets', () => {
   it('should get the input from the active editor selection', async () => {

packages/foam-vscode/src/features/dataviz.ts

@@ -33,13 +33,9 @@ const feature: FoamFeature = {
           updateGraph(panel, foam);
         };
 
-        const noteAddedListener = foam.workspace.onDidAdd(onFoamChanged);
-        const noteUpdatedListener = foam.workspace.onDidUpdate(onFoamChanged);
-        const noteDeletedListener = foam.workspace.onDidDelete(onFoamChanged);
+        const noteUpdatedListener = foam.graph.onDidUpdate(onFoamChanged);
         panel.onDidDispose(() => {
-          noteAddedListener.dispose();
           noteUpdatedListener.dispose();
-          noteDeletedListener.dispose();
           panel = undefined;
         });
 

packages/foam-vscode/src/features/hover-provider.spec.ts

@@ -1,8 +1,6 @@
 import * as vscode from 'vscode';
-import {
-  createMarkdownParser,
-  MarkdownResourceProvider,
-} from '../core/markdown-provider';
+import { createMarkdownParser } from '../core/services/markdown-parser';
+import { MarkdownResourceProvider } from '../core/services/markdown-provider';
 import { FoamGraph } from '../core/model/graph';
 import { FoamWorkspace } from '../core/model/workspace';
 import { Matcher } from '../core/services/datastore';

packages/foam-vscode/src/features/index.ts

@@ -18,9 +18,11 @@ import tagCompletionProvider from './tag-completion';
 import linkDecorations from './document-decorator';
 import navigationProviders from './navigation-provider';
 import wikilinkDiagnostics from './wikilink-diagnostics';
+import refactor from './refactor';
 import { FoamFeature } from '../types';
 
 export const features: FoamFeature[] = [
+  refactor,
   navigationProviders,
   wikilinkDiagnostics,
   tagsExplorer,

packages/foam-vscode/src/features/link-completion.spec.ts

@@ -1,8 +1,7 @@
 import * as vscode from 'vscode';
-import { createMarkdownParser } from '../core/markdown-provider';
+import { createMarkdownParser } from '../core/services/markdown-parser';
 import { FoamGraph } from '../core/model/graph';
-import { FoamWorkspace } from '../core/model/workspace';
-import { createTestNote } from '../test/test-utils';
+import { createTestNote, createTestWorkspace } from '../test/test-utils';
 import {
   cleanWorkspace,
   closeEditors,
@@ -18,7 +17,7 @@ import {
 describe('Link Completion', () => {
   const parser = createMarkdownParser([]);
   const root = fromVsCodeUri(vscode.workspace.workspaceFolders[0].uri);
-  const ws = new FoamWorkspace();
+  const ws = createTestWorkspace();
   ws.set(
     createTestNote({
       root,

packages/foam-vscode/src/features/navigation-provider.spec.ts

@@ -10,8 +10,7 @@ import {
 import { NavigationProvider } from './navigation-provider';
 import { OPEN_COMMAND } from './utility-commands';
 import { toVsCodeUri } from '../utils/vsc-utils';
-import { createMarkdownParser } from '../core/markdown-provider';
-import { FoamWorkspace } from '../core/model/workspace';
+import { createMarkdownParser } from '../core/services/markdown-parser';
 import { FoamGraph } from '../core/model/graph';
 
 describe('Document navigation', () => {
@@ -31,7 +30,7 @@ describe('Document navigation', () => {
   describe('Document links provider', () => {
     it('should not return any link for empty documents', async () => {
       const { uri, content } = await createFile('');
-      const ws = new FoamWorkspace().set(parser.parse(uri, content));
+      const ws = createTestWorkspace().set(parser.parse(uri, content));
       const graph = FoamGraph.fromWorkspace(ws);
 
       const doc = await vscode.workspace.openTextDocument(toVsCodeUri(uri));
@@ -45,7 +44,7 @@ describe('Document navigation', () => {
       const { uri, content } = await createFile(
         'This is some content without links'
       );
-      const ws = new FoamWorkspace().set(parser.parse(uri, content));
+      const ws = createTestWorkspace().set(parser.parse(uri, content));
       const graph = FoamGraph.fromWorkspace(ws);
 
       const doc = await vscode.workspace.openTextDocument(toVsCodeUri(uri));
@@ -74,7 +73,7 @@ describe('Document navigation', () => {
 
     it('should create links for placeholders', async () => {
       const fileA = await createFile(`this is a link to [[a placeholder]].`);
-      const ws = new FoamWorkspace().set(
+      const ws = createTestWorkspace().set(
         parser.parse(fileA.uri, fileA.content)
       );
       const graph = FoamGraph.fromWorkspace(ws);
@@ -232,6 +231,6 @@ describe('Document navigation', () => {
         range: new vscode.Range(0, 23, 0, 23 + 9),
       });
     });
-    // it('should provide references for placeholders', async () => {});
+    it.todo('should provide references for placeholders');
   });
 });

packages/foam-vscode/src/features/navigation-provider.ts

@@ -115,22 +115,23 @@ export class NavigationProvider
     }
 
     const targetResource = this.workspace.get(uri);
-
-    let targetRange = Range.createFromPosition(
-      targetResource.source.contentStart,
-      targetResource.source.end
-    );
     const section = Resource.findSection(targetResource, uri.fragment);
-    if (section) {
-      targetRange = section.range;
-    }
+
+    const targetRange = section
+      ? section.range
+      : Range.createFromPosition(
+          targetResource.source.contentStart,
+          targetResource.source.end
+        );
+    const targetSelectionRange = section
+      ? section.range
+      : Range.createFromPosition(targetRange.start);
+
     const result: vscode.LocationLink = {
       originSelectionRange: toVsCodeRange(targetLink.range),
-      targetUri: toVsCodeUri(uri),
+      targetUri: toVsCodeUri(uri.asPlain()),
       targetRange: toVsCodeRange(targetRange),
-      targetSelectionRange: toVsCodeRange(
-        Range.createFromPosition(targetRange.start, targetRange.start)
-      ),
+      targetSelectionRange: toVsCodeRange(targetSelectionRange),
     };
     return [result];
   }

packages/foam-vscode/src/features/orphans.ts

@@ -40,9 +40,7 @@ const feature: FoamFeature = {
     context.subscriptions.push(
       vscode.window.registerTreeDataProvider('foam-vscode.orphans', provider),
       ...provider.commands,
-      foam.workspace.onDidAdd(() => provider.refresh()),
-      foam.workspace.onDidUpdate(() => provider.refresh()),
-      foam.workspace.onDidDelete(() => provider.refresh())
+      foam.graph.onDidUpdate(() => provider.refresh())
     );
   },
 };

packages/foam-vscode/src/features/placeholders.ts

@@ -44,9 +44,7 @@ const feature: FoamFeature = {
         provider
       ),
       ...provider.commands,
-      foam.workspace.onDidAdd(() => provider.refresh()),
-      foam.workspace.onDidUpdate(() => provider.refresh()),
-      foam.workspace.onDidDelete(() => provider.refresh())
+      foam.graph.onDidUpdate(() => provider.refresh())
     );
   },
 };

packages/foam-vscode/src/features/preview-navigation.spec.ts

@@ -1,5 +1,5 @@
 import MarkdownIt from 'markdown-it';
-import { createMarkdownParser } from '../core/markdown-provider';
+import { createMarkdownParser } from '../core/services/markdown-parser';
 import { FoamWorkspace } from '../core/model/workspace';
 import { createTestNote } from '../test/test-utils';
 import {

packages/foam-vscode/src/features/refactor.spec.ts

@@ -0,0 +1,207 @@
+import { wait, waitForExpect } from '../test/test-utils';
+import {
+  closeEditors,
+  createFile,
+  cleanWorkspace,
+  readFile,
+  renameFile,
+  showInEditor,
+} from '../test/test-utils-vscode';
+
+describe('Note rename sync', () => {
+  beforeAll(async () => {
+    await closeEditors();
+    await cleanWorkspace();
+  });
+  afterAll(closeEditors);
+
+  describe('wikilinks', () => {
+    it('should sync wikilinks to renamed notes', async () => {
+      const noteA = await createFile(`Content of note A`, [
+        'refactor',
+        'wikilinks',
+        'rename-note-a.md',
+      ]);
+      const noteB = await createFile(
+        `Link to [[${noteA.name}]]. Also a [[placeholder]] and again [[${noteA.name}]]`,
+        ['refactor', 'wikilinks', 'rename-note-b.md']
+      );
+      const noteC = await createFile(`Link to [[${noteA.name}]] from note C.`, [
+        'refactor',
+        'wikilinks',
+        'rename-note-c.md',
+      ]);
+      const { doc } = await showInEditor(noteB.uri);
+
+      const newName = 'renamed-note-a';
+      const newUri = noteA.uri.resolve(newName);
+
+      // wait for workspace files to be added to graph (because of graph debounced update)
+      // TODO this should be replaced by either a force-refresh command or by Foam updating immediately in test mode
+      await wait(600);
+      await renameFile(noteA.uri, newUri);
+
+      await waitForExpect(async () => {
+        // check it updates documents open in editors
+        expect(doc.getText().trim()).toEqual(
+          `Link to [[${newName}]]. Also a [[placeholder]] and again [[${newName}]]`
+        );
+        // and documents not open in editors
+        expect((await readFile(noteC.uri)).trim()).toEqual(
+          `Link to [[${newName}]] from note C.`
+        );
+      }, 1000);
+    });
+
+    it('should use the best identifier based on the new note location', async () => {
+      const noteA = await createFile(`Content of note A`, [
+        'refactor',
+        'wikilink',
+        'first',
+        'note-a.md',
+      ]);
+      await createFile(`Content of note B`, [
+        'refactor',
+        'wikilink',
+        'second',
+        'note-b.md',
+      ]);
+      const noteC = await createFile(`Link to [[${noteA.name}]] from note C.`);
+
+      const { doc } = await showInEditor(noteC.uri);
+
+      // rename note A
+      const newUri = noteA.uri.resolve('note-b.md');
+
+      // wait for workspace files to be added to graph (because of graph debounced update)
+      // TODO this should be replaced by either a force-refresh command or by Foam updating immediately in test mode
+      await wait(600);
+      await renameFile(noteA.uri, newUri);
+
+      await waitForExpect(async () => {
+        expect(doc.getText().trim()).toEqual(
+          `Link to [[first/note-b]] from note C.`
+        );
+      });
+    });
+
+    it('should use the best identifier when moving the note to another directory', async () => {
+      const noteA = await createFile(`Content of note A`, [
+        'refactor',
+        'wikilink',
+        'first',
+        'note-a.md',
+      ]);
+      await createFile(`Content of note B`, [
+        'refactor',
+        'wikilink',
+        'second',
+        'note-b.md',
+      ]);
+      const noteC = await createFile(`Link to [[${noteA.name}]] from note C.`);
+
+      const { doc } = await showInEditor(noteC.uri);
+
+      const newUri = noteA.uri.resolve('../second/note-a.md');
+
+      // wait for workspace files to be added to graph (because of graph debounced update)
+      // TODO this should be replaced by either a force-refresh command or by Foam updating immediately in test mode
+      await wait(600);
+      await renameFile(noteA.uri, newUri);
+
+      await waitForExpect(async () => {
+        expect(doc.getText().trim()).toEqual(`Link to [[note-a]] from note C.`);
+      });
+    });
+
+    it('should keep the alias in wikilinks', async () => {
+      const noteA = await createFile(`Content of note A`);
+      const noteB = await createFile(`Link to [[${noteA.name}|Alias]]`);
+
+      const { doc } = await showInEditor(noteB.uri);
+
+      // rename note A
+      const newUri = noteA.uri.resolve('new-note-a.md');
+      // wait for workspace files to be added to graph (because of graph debounced update)
+      // TODO this should be replaced by either a force-refresh command or by Foam updating immediately in test mode
+      await wait(600);
+      await renameFile(noteA.uri, newUri);
+
+      await waitForExpect(async () => {
+        expect(doc.getText().trim()).toEqual(`Link to [[new-note-a|Alias]]`);
+      });
+    });
+
+    it('should keep the section part of the wikilink', async () => {
+      const noteA = await createFile(`Content of note A`);
+      const noteB = await createFile(`Link to [[${noteA.name}#Section]]`);
+
+      const { doc } = await showInEditor(noteB.uri);
+
+      // rename note A
+      const newUri = noteA.uri.resolve('new-note-with-section.md');
+      // wait for workspace files to be added to graph (because of graph debounced update)
+      // TODO this should be replaced by either a force-refresh command or by Foam updating immediately in test mode
+      await wait(600);
+      await renameFile(noteA.uri, newUri);
+
+      await waitForExpect(async () => {
+        expect(doc.getText().trim()).toEqual(
+          `Link to [[new-note-with-section#Section]]`
+        );
+      });
+    });
+
+    it('should sync when moving the note to a new folder', async () => {
+      const noteA = await createFile(`Content of note A`, [
+        'refactor',
+        'first',
+        'note-a.md',
+      ]);
+      const noteC = await createFile(`Link to [[note-a]] from note C.`);
+
+      const newUri = noteA.uri.resolve('../note-a.md');
+      // wait for workspace files to be added to graph (because of graph debounced update)
+      // TODO this should be replaced by either a force-refresh command or by Foam updating immediately in test mode
+      await wait(600);
+      await renameFile(noteA.uri, newUri);
+
+      const content = await readFile(noteC.uri);
+      await waitForExpect(async () => {
+        expect(content.trim()).toEqual(`Link to [[note-a]] from note C.`);
+      });
+    });
+  });
+
+  describe('direct links', () => {
+    beforeAll(async () => {
+      await closeEditors();
+      await cleanWorkspace();
+    });
+    beforeEach(closeEditors);
+
+    it('should rename relative direct links', async () => {
+      const noteA = await createFile(
+        `Content of note A. Lorem etc etc etc etc`,
+        ['refactor', 'direct-links', 'f1', 'note-a.md']
+      );
+      const noteB = await createFile(
+        `Link to [note](../f1/note-a.md) from note B.`,
+        ['refactor', 'direct-links', 'f2', 'note-b.md']
+      );
+      const { doc } = await showInEditor(noteB.uri);
+
+      const newUri = noteA.uri.resolve('../note-a.md');
+      // wait for workspace files to be added to graph (because of graph debounced update)
+      // TODO this should be replaced by either a force-refresh command or by Foam updating immediately in test mode
+      await wait(600);
+      await renameFile(noteA.uri, newUri);
+
+      await waitForExpect(async () => {
+        expect(doc.getText().trim()).toEqual(
+          `Link to [note](../note-a.md) from note B.`
+        );
+      });
+    });
+  });
+});

packages/foam-vscode/src/features/refactor.ts

@@ -0,0 +1,108 @@
+import * as vscode from 'vscode';
+import { Foam } from '../core/model/foam';
+import { MarkdownLink } from '../core/services/markdown-link';
+import { Logger } from '../core/utils/log';
+import { isAbsolute } from '../core/utils/path';
+import { getFoamVsCodeConfig } from '../services/config';
+import { FoamFeature } from '../types';
+import { fromVsCodeUri, toVsCodeRange, toVsCodeUri } from '../utils/vsc-utils';
+
+const feature: FoamFeature = {
+  activate: async (
+    context: vscode.ExtensionContext,
+    foamPromise: Promise<Foam>
+  ) => {
+    const foam = await foamPromise;
+
+    context.subscriptions.push(
+      vscode.workspace.onWillRenameFiles(async e => {
+        if (!getFoamVsCodeConfig<boolean>('links.sync.enable')) {
+          return;
+        }
+        const renameEdits = new vscode.WorkspaceEdit();
+        e.files.forEach(({ oldUri, newUri }) => {
+          const connections = foam.graph.getBacklinks(fromVsCodeUri(oldUri));
+          connections.forEach(async connection => {
+            const { target } = MarkdownLink.analyzeLink(connection.link);
+            switch (connection.link.type) {
+              case 'wikilink': {
+                const identifier = foam.workspace.getIdentifier(
+                  fromVsCodeUri(newUri),
+                  [fromVsCodeUri(oldUri)]
+                );
+                const edit = MarkdownLink.createUpdateLinkEdit(
+                  connection.link,
+                  { target: identifier }
+                );
+                renameEdits.replace(
+                  toVsCodeUri(connection.source),
+                  toVsCodeRange(edit.selection),
+                  edit.newText
+                );
+                break;
+              }
+              case 'link': {
+                const path = isAbsolute(target)
+                  ? '/' + vscode.workspace.asRelativePath(newUri)
+                  : fromVsCodeUri(newUri).relativeTo(
+                      connection.source.getDirectory()
+                    ).path;
+                const edit = MarkdownLink.createUpdateLinkEdit(
+                  connection.link,
+                  { target: path }
+                );
+                renameEdits.replace(
+                  toVsCodeUri(connection.source),
+                  toVsCodeRange(edit.selection),
+                  edit.newText
+                );
+                break;
+              }
+            }
+          });
+        });
+
+        try {
+          if (renameEdits.size > 0) {
+            // We break the update by file because applying it at once was causing
+            // dirty state and editors not always saving or closing
+            for (const renameEditForUri of renameEdits.entries()) {
+              const [uri, edits] = renameEditForUri;
+              const fileEdits = new vscode.WorkspaceEdit();
+              fileEdits.set(uri, edits);
+              await vscode.workspace.applyEdit(fileEdits);
+              const editor = await vscode.workspace.openTextDocument(uri);
+              // Because the save happens within 50ms of opening the doc, it will be then closed
+              editor.save();
+            }
+
+            // Reporting
+            const nUpdates = renameEdits.entries().reduce((acc, entry) => {
+              return (acc += entry[1].length);
+            }, 0);
+            const links = nUpdates > 1 ? 'links' : 'link';
+            const nFiles = renameEdits.size;
+            const files = nFiles > 1 ? 'files' : 'file';
+            Logger.info(
+              `Updated links in the following files:`,
+              ...renameEdits
+                .entries()
+                .map(e => vscode.workspace.asRelativePath(e[0]))
+            );
+            vscode.window.showInformationMessage(
+              `Updated ${nUpdates} ${links} across ${nFiles} ${files}.`
+            );
+          }
+        } catch (e) {
+          Logger.error('Error while updating references to file', e);
+          vscode.window.showErrorMessage(
+            `Foam couldn't update the links to ${vscode.workspace.asRelativePath(
+              e.newUri
+            )}. Check the logs for error details.`
+          );
+        }
+      })
+    );
+  },
+};
+export default feature;

packages/foam-vscode/src/features/tags-tree-view.spec.ts

@@ -2,7 +2,7 @@ import { createTestNote } from '../test/test-utils';
 import { cleanWorkspace, closeEditors } from '../test/test-utils-vscode';
 import { TagItem, TagReference, TagsProvider } from './tags-tree-view';
 import { bootstrap, Foam } from '../core/model/foam';
-import { MarkdownResourceProvider } from '../core/markdown-provider';
+import { MarkdownResourceProvider } from '../core/services/markdown-provider';
 import { FileDataStore, Matcher } from '../core/services/datastore';
 
 describe('Tags tree panel', () => {

packages/foam-vscode/src/features/tags-tree-view.ts

@@ -21,9 +21,7 @@ const feature: FoamFeature = {
         provider
       )
     );
-    foam.workspace.onDidUpdate(() => provider.refresh());
-    foam.workspace.onDidAdd(() => provider.refresh());
-    foam.workspace.onDidDelete(() => provider.refresh());
+    foam.tags.onDidUpdate(() => provider.refresh());
   },
 };
 

packages/foam-vscode/src/features/utility-commands.ts

@@ -1,10 +1,9 @@
 import * as vscode from 'vscode';
 import { FoamFeature } from '../types';
 import { URI } from '../core/model/uri';
-import { fromVsCodeUri, toVsCodeRange, toVsCodeUri } from '../utils/vsc-utils';
+import { fromVsCodeUri, toVsCodeUri } from '../utils/vsc-utils';
 import { NoteFactory } from '../services/templates';
 import { Foam } from '../core/model/foam';
-import { Resource } from '../core/model/note';
 
 export const OPEN_COMMAND = {
   command: 'foam-vscode.open-resource',
@@ -25,21 +24,16 @@ const feature: FoamFeature = {
           const uri = new URI(params.uri);
           switch (uri.scheme) {
             case 'file': {
-              let selection = new vscode.Range(1, 0, 1, 0);
-              if (uri.fragment) {
-                const foam = await foamPromise;
-                const resource = foam.workspace.get(uri);
-                const section = Resource.findSection(resource, uri.fragment);
-                if (section) {
-                  selection = toVsCodeRange(section.range);
-                }
-              }
               const targetUri =
                 uri.path === vscode.window.activeTextEditor?.document.uri.path
                   ? vscode.window.activeTextEditor?.document.uri
-                  : toVsCodeUri(uri);
-              return vscode.commands.executeCommand('vscode.open', targetUri, {
-                selection: selection,
+                  : toVsCodeUri(uri.asPlain());
+              const targetEditor = vscode.window.visibleTextEditors.find(
+                ed => targetUri.path === ed.document.uri.path
+              );
+              const column = targetEditor?.viewColumn;
+              return vscode.window.showTextDocument(targetUri, {
+                viewColumn: column,
               });
             }
             case 'placeholder': {

packages/foam-vscode/src/features/wikilink-diagnostics.spec.ts

@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import { createMarkdownParser } from '../core/markdown-provider';
+import { createMarkdownParser } from '../core/services/markdown-parser';
 import { FoamWorkspace } from '../core/model/workspace';
 import {
   cleanWorkspace,

packages/foam-vscode/src/features/wikilink-diagnostics.ts

@@ -4,6 +4,7 @@ import { Foam } from '../core/model/foam';
 import { Resource, ResourceParser } from '../core/model/note';
 import { Range } from '../core/model/range';
 import { FoamWorkspace } from '../core/model/workspace';
+import { MarkdownLink } from '../core/services/markdown-link';
 import { FoamFeature } from '../types';
 import { isNone } from '../utils';
 import {
@@ -131,7 +132,7 @@ export function updateDiagnostics(
 
     for (const link of resource.links) {
       if (link.type === 'wikilink') {
-        const [target, section] = link.target.split('#');
+        const { target, section } = MarkdownLink.analyzeLink(link);
         const targets = workspace.listByIdentifier(target);
         if (targets.length > 1) {
           result.push({

packages/foam-vscode/src/features/wikilink-reference-generation.ts

@@ -30,7 +30,7 @@ import { FoamWorkspace } from '../core/model/workspace';
 import {
   createMarkdownReferences,
   stringifyMarkdownLinkReferenceDefinition,
-} from '../core/markdown-provider';
+} from '../core/services/markdown-provider';
 import {
   LINK_REFERENCE_DEFINITION_FOOTER,
   LINK_REFERENCE_DEFINITION_HEADER,
@@ -45,10 +45,11 @@ const feature: FoamFeature = {
       commands.registerCommand('foam-vscode.update-wikilinks', () =>
         updateReferenceList(foam.workspace)
       ),
-
       workspace.onWillSaveTextDocument(e => {
-        if (e.document.languageId === 'markdown') {
-          updateDocumentInNoteGraph(foam, e.document);
+        if (
+          e.document.languageId === 'markdown' &&
+          foam.services.matcher.isMatch(fromVsCodeUri(e.document.uri))
+        ) {
           e.waitUntil(updateReferenceList(foam.workspace));
         }
       }),
@@ -57,27 +58,9 @@ const feature: FoamFeature = {
         new WikilinkReferenceCodeLensProvider(foam.workspace)
       )
     );
-
-    // when a file is created as a result of peekDefinition
-    // action on a wikilink, add definition update references
-    foam.workspace.onDidAdd(_ => {
-      const editor = window.activeTextEditor;
-      if (!editor || !isMdEditor(editor)) {
-        return;
-      }
-
-      updateDocumentInNoteGraph(foam, editor.document);
-      updateReferenceList(foam.workspace);
-    });
   },
 };
 
-function updateDocumentInNoteGraph(foam: Foam, document: TextDocument) {
-  foam.workspace.set(
-    foam.services.parser.parse(fromVsCodeUri(document.uri), document.getText())
-  );
-}
-
 async function createReferenceList(foam: FoamWorkspace) {
   const editor = window.activeTextEditor;
 

packages/foam-vscode/src/services/templates.spec.ts

@@ -50,7 +50,7 @@ describe('Create note from template', () => {
       const templateA = await createFile(
         `---
 foam_template: # foam template metadata
-  filepath: "${uri.toFsPath()}"
+  filepath: ${uri.toFsPath()}
 ---
 `,
         ['.foam', 'templates', 'template-with-path.md']

packages/foam-vscode/src/services/variable-resolver.ts

@@ -126,136 +126,80 @@ export class Resolver implements VariableResolver {
     if (this.givenValues.has(name)) {
       this.promises.set(name, Promise.resolve(this.givenValues.get(name)));
     } else if (!this.promises.has(name)) {
+      let value: Promise<string | undefined> = Promise.resolve(undefined);
       switch (name) {
         case 'FOAM_TITLE':
-          this.promises.set(name, resolveFoamTitle());
+          value = resolveFoamTitle();
           break;
         case 'FOAM_SLUG':
-          this.promises.set(
-            name,
-            Promise.resolve(
-              toSlug(await this.resolve(new Variable('FOAM_TITLE')))
-            )
-          );
+          value = toSlug(await this.resolve(new Variable('FOAM_TITLE')));
           break;
         case 'FOAM_SELECTED_TEXT':
-          this.promises.set(name, Promise.resolve(resolveFoamSelectedText()));
+          value = Promise.resolve(resolveFoamSelectedText());
           break;
         case 'FOAM_DATE_YEAR':
-          this.promises.set(
-            name,
-            Promise.resolve(
-              this.foamDate.toLocaleString('default', { year: 'numeric' })
-            )
-          );
+          value = Promise.resolve(String(this.foamDate.getFullYear()));
           break;
         case 'FOAM_DATE_YEAR_SHORT':
-          this.promises.set(
-            name,
-            Promise.resolve(
-              this.foamDate.toLocaleString('default', { year: '2-digit' })
-            )
+          value = Promise.resolve(
+            String(this.foamDate.getFullYear()).slice(-2)
           );
           break;
         case 'FOAM_DATE_MONTH':
-          this.promises.set(
-            name,
-            Promise.resolve(
-              this.foamDate.toLocaleString('default', { month: '2-digit' })
-            )
+          value = Promise.resolve(
+            String(this.foamDate.getMonth().valueOf() + 1).padStart(2, '0')
           );
           break;
         case 'FOAM_DATE_MONTH_NAME':
-          this.promises.set(
-            name,
-            Promise.resolve(
-              this.foamDate.toLocaleString('default', { month: 'long' })
-            )
+          value = Promise.resolve(
+            this.foamDate.toLocaleString('default', { month: 'long' })
           );
           break;
         case 'FOAM_DATE_MONTH_NAME_SHORT':
-          this.promises.set(
-            name,
-            Promise.resolve(
-              this.foamDate.toLocaleString('default', { month: 'short' })
-            )
+          value = Promise.resolve(
+            this.foamDate.toLocaleString('default', { month: 'short' })
           );
           break;
         case 'FOAM_DATE_DATE':
-          this.promises.set(
-            name,
-            Promise.resolve(
-              this.foamDate.toLocaleString('default', { day: '2-digit' })
-            )
+          value = Promise.resolve(
+            String(this.foamDate.getDate().valueOf()).padStart(2, '0')
           );
           break;
         case 'FOAM_DATE_DAY_NAME':
-          this.promises.set(
-            name,
-            Promise.resolve(
-              this.foamDate.toLocaleString('default', { weekday: 'long' })
-            )
+          value = Promise.resolve(
+            this.foamDate.toLocaleString('default', { weekday: 'long' })
           );
           break;
         case 'FOAM_DATE_DAY_NAME_SHORT':
-          this.promises.set(
-            name,
-            Promise.resolve(
-              this.foamDate.toLocaleString('default', { weekday: 'short' })
-            )
+          value = Promise.resolve(
+            this.foamDate.toLocaleString('default', { weekday: 'short' })
           );
           break;
         case 'FOAM_DATE_HOUR':
-          this.promises.set(
-            name,
-            Promise.resolve(
-              this.foamDate
-                .toLocaleString('default', {
-                  hour: '2-digit',
-                  hour12: false,
-                })
-                .padStart(2, '0')
-            )
+          value = Promise.resolve(
+            String(this.foamDate.getHours().valueOf()).padStart(2, '0')
           );
           break;
         case 'FOAM_DATE_MINUTE':
-          this.promises.set(
-            name,
-            Promise.resolve(
-              this.foamDate
-                .toLocaleString('default', {
-                  minute: '2-digit',
-                  hour12: false,
-                })
-                .padStart(2, '0')
-            )
+          value = Promise.resolve(
+            String(this.foamDate.getMinutes().valueOf()).padStart(2, '0')
           );
           break;
         case 'FOAM_DATE_SECOND':
-          this.promises.set(
-            name,
-            Promise.resolve(
-              this.foamDate
-                .toLocaleString('default', {
-                  second: '2-digit',
-                  hour12: false,
-                })
-                .padStart(2, '0')
-            )
+          value = Promise.resolve(
+            String(this.foamDate.getSeconds().valueOf()).padStart(2, '0')
           );
           break;
         case 'FOAM_DATE_SECONDS_UNIX':
-          this.promises.set(
-            name,
-            Promise.resolve(
-              (this.foamDate.getTime() / 1000).toString().padStart(2, '0')
-            )
+          value = Promise.resolve(
+            (this.foamDate.getTime() / 1000).toString().padStart(2, '0')
           );
           break;
         default:
-          this.promises.set(name, Promise.resolve(undefined));
+          value = Promise.resolve(undefined);
           break;
       }
+      this.promises.set(name, value);
     }
     const result = this.promises.get(name);
     return result;

packages/foam-vscode/src/test/test-utils-vscode.ts

@@ -3,7 +3,7 @@
  */
 import * as vscode from 'vscode';
 import path from 'path';
-import { TextEncoder } from 'util';
+import { TextDecoder, TextEncoder } from 'util';
 import { fromVsCodeUri, toVsCodeUri } from '../utils/vsc-utils';
 import { Logger } from '../core/utils/log';
 import { URI } from '../core/model/uri';
@@ -64,13 +64,23 @@ export const createFile = async (content: string, filepath: string[] = []) => {
   return { uri, content, ...filenameComponents };
 };
 
+export const renameFile = (from: URI, to: URI) => {
+  const edit = new vscode.WorkspaceEdit();
+  edit.renameFile(toVsCodeUri(from), toVsCodeUri(to));
+  return vscode.workspace.applyEdit(edit);
+};
+
+const decoder = new TextDecoder('utf-8');
+export const readFile = async (uri: URI) => {
+  const content = await vscode.workspace.fs.readFile(toVsCodeUri(uri));
+  return decoder.decode(content);
+};
+
 export const createNote = (r: Resource) => {
   const content = `# ${r.title}
 
   some content and ${r.links
-    .map(l =>
-      l.type === 'wikilink' ? `[[${l.label}]]` : `[${l.label}](${l.target})`
-    )
+    .map(l => l.rawText)
     .join(' some content between links.\n')}
   last line.
 `;

packages/foam-vscode/src/test/test-utils.ts

@@ -6,9 +6,11 @@ import { Range } from '../core/model/range';
 import { URI } from '../core/model/uri';
 import { FoamWorkspace } from '../core/model/workspace';
 import { Matcher } from '../core/services/datastore';
-import { MarkdownResourceProvider } from '../core/markdown-provider';
+import { MarkdownResourceProvider } from '../core/services/markdown-provider';
 import { NoteLinkDefinition, Resource } from '../core/model/note';
 
+export { default as waitForExpect } from 'wait-for-expect';
+
 Logger.setLevel('error');
 
 export const TEST_DATA_DIR = URI.file(__dirname).joinPath(
@@ -78,16 +80,13 @@ export const createTestNote = (params: {
           return 'slug' in link
             ? {
                 type: 'wikilink',
-                target: link.slug,
-                label: link.slug,
                 range: range,
-                rawText: 'link text',
+                rawText: `[[${link.slug}]]`,
               }
             : {
                 type: 'link',
-                target: link.to,
-                label: 'link text',
                 range: range,
+                rawText: `[link text](${link.to})`,
               };
         })
       : [],

readme.md

@@ -30,6 +30,12 @@ Foam helps you create the connections between your notes, and your placeholders
 
 ![Link Autocompletion](./assets/screenshots/feature-link-autocompletion.gif)
 
+### Sync links on file rename
+
+Foam updates the links to renamed files, so your notes stay consistent.
+
+![Sync links on file rename](./assets/screenshots/feature-link-sync.gif)
+
 ### Unique identifiers across directories
 
 Foam supports files with the same name in multiple directories.

yarn.lock

@@ -11229,6 +11229,11 @@ w3c-xmlserializer@^2.0.0:
   dependencies:
     xml-name-validator "^3.0.0"
 
+wait-for-expect@^3.0.2:
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/wait-for-expect/-/wait-for-expect-3.0.2.tgz#d2f14b2f7b778c9b82144109c8fa89ceaadaa463"
+  integrity sha512-cfS1+DZxuav1aBYbaO/kE06EOS8yRw7qOFoD3XtjTkYvCvh3zUvNST8DXK/nPaeqIzIv3P3kL3lRJn8iwOiSag==
+
 walker@^1.0.7, walker@~1.0.5:
   version "1.0.7"
   resolved "https://registry.yarnpkg.com/walker/-/walker-1.0.7.tgz#2f7f9b8fd10d677262b18a884e28d19618e028fb"