v0.18.2

* docs: update docs/index.md [skip ci]

* docs: update readme.md [skip ci]

* docs: update .all-contributorsrc [skip ci]

Co-authored-by: allcontributors[bot] <46447321+allcontributors[bot]@users.noreply.github.com>

.all-contributorsrc

@@ -806,6 +806,69 @@
       "contributions": [
         "doc"
       ]
+    },
+    {
+      "login": "MalcolmMielle",
+      "name": "Malcolm Mielle",
+      "avatar_url": "https://avatars.githubusercontent.com/u/4457840?v=4",
+      "profile": "http://malcolmmielle.wordpress.com/",
+      "contributions": [
+        "doc"
+      ]
+    },
+    {
+      "login": "veesar",
+      "name": "Veesar",
+      "avatar_url": "https://avatars.githubusercontent.com/u/74916913?v=4",
+      "profile": "https://snippets.page/",
+      "contributions": [
+        "doc"
+      ]
+    },
+    {
+      "login": "bentongxyz",
+      "name": "bentongxyz",
+      "avatar_url": "https://avatars.githubusercontent.com/u/60358804?v=4",
+      "profile": "https://github.com/bentongxyz",
+      "contributions": [
+        "code"
+      ]
+    },
+    {
+      "login": "techCarpenter",
+      "name": "Brian DeVries",
+      "avatar_url": "https://avatars.githubusercontent.com/u/42778030?v=4",
+      "profile": "https://brianjdevries.com",
+      "contributions": [
+        "code"
+      ]
+    },
+    {
+      "login": "cliffordfajardo",
+      "name": "Clifford Fajardo ",
+      "avatar_url": "https://avatars.githubusercontent.com/u/6743796?v=4",
+      "profile": "http://Cliffordfajardo.com",
+      "contributions": [
+        "tool"
+      ]
+    },
+    {
+      "login": "chrisUsick",
+      "name": "Chris Usick",
+      "avatar_url": "https://avatars.githubusercontent.com/u/6589365?v=4",
+      "profile": "http://cu-dev.ca",
+      "contributions": [
+        "code"
+      ]
+    },
+    {
+      "login": "josephdecock",
+      "name": "Joe DeCock",
+      "avatar_url": "https://avatars.githubusercontent.com/u/1145533?v=4",
+      "profile": "https://github.com/josephdecock",
+      "contributions": [
+        "code"
+      ]
     }
   ],
   "contributorsPerLine": 7,

.eslintrc.json

@@ -5,14 +5,40 @@
     "ecmaVersion": 6,
     "sourceType": "module"
   },
-  "plugins": ["@typescript-eslint", "import"],
+  "env": { "node": true, "es6": true },
+  "plugins": ["@typescript-eslint", "import", "jest"],
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended",
+    "plugin:import/recommended",
+    "plugin:import/typescript",
+    "plugin:jest/recommended"
+  ],
   "rules": {
-    "@typescript-eslint/class-name-casing": "warn",
-    "@typescript-eslint/semi": "warn",
-    "curly": "warn",
-    "eqeqeq": "warn",
-    "no-throw-literal": "warn",
-    "semi": "off",
-    "require-await": "warn"
-  }
+    "no-use-before-define": "off",
+    "@typescript-eslint/no-use-before-define": "off",
+    "@typescript-eslint/no-explicit-any": "off",
+    "@typescript-eslint/no-non-null-assertion": "off",
+    "@typescript-eslint/explicit-function-return-type": "off",
+    "@typescript-eslint/interface-name-prefix": "off",
+    "import/no-extraneous-dependencies": [
+      "error",
+      {
+        "devDependencies": ["**/src/test/**", "**/src/**/*{test,spec}.ts"]
+      }
+    ]
+  },
+  "settings": {
+    "import/core-modules": ["vscode"],
+    "import/parsers": {
+      "@typescript-eslint/parser": [".ts", ".tsx"]
+    },
+    "import/resolver": {
+      "typescript": {
+        "alwaysTryTypes": true
+      }
+    }
+  },
+  "ignorePatterns": ["**/core/common/**", "*.js"],
+  "reportUnusedDisableDirectives": true
 }

.github/ISSUE_TEMPLATE/bug.md

@@ -1,23 +0,0 @@
----
-name: Bug report
-about: Create a report to help us be foamier
-labels: bug
----
-
-- Foam version: <!-- Check in the VSCode extension tab. -->
-- Platform: Windows | Mac | Linux
-- Issue occur on the [foam template](https://github.com/foambubble/foam-template) repo: Yes | No
-
-**Summary**
-<!-- A clear and concise description of what the bug is.-->
-
-**Steps to reproduce**
-1.
-2.
-
-**Additional information**
-<!-- Add any other context about the problem here. -->
-Feel free to attach any of the following that might help with debugging the issue:
-- screenshots
-- a zip with a minimal repo to reproduce the issue
-- the Foam log in VsCode (see [instructions](https://github.com/foambubble/foam/blob/master/docs/features/foam-logging-in-vscode.md))

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,97 @@
+name: 'Bug report'
+description: Create a report to help us improve
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thank you for reporting an issue :pray:.
+
+        This issue tracker is for reporting bugs found in `foam` (https://github.com/foambubble).
+        If you have a question about how to achieve something and are struggling, please post a question
+        inside of either of the following places:
+          - Foam's Discussion's tab: https://github.com/foambubble/foam/discussions
+          - Foam's Discord channel: https://foambubble.github.io/join-discord/g
+          
+
+        Before submitting a new bug/issue, please check the links below to see if there is a solution or question posted there already:
+         - Foam's Issue's tab: https://github.com/foambubble/foam/pulls?q=is%3Apr+is%3Aopen+sort%3Aupdated-desc
+         - Foam's closed issues tab: https://github.com/foambubble/foam/issues?q=is%3Aissue+sort%3Aupdated-desc+is%3Aclosed
+         - Foam's Discussions tab: https://github.com/foambubble/foam/discussions
+
+        The more information you fill in, the better the community can help you.
+  - type: textarea
+    id: description
+    attributes:
+      label: Describe the bug
+      description: Provide a clear and concise description of the challenge you are running into.
+    validations:
+      required: true
+  - type: input
+    id: reproducible_example
+    attributes:
+      label: Small Reproducible Example
+      description: |
+        Note:
+        - Your bug will may get fixed much faster if there is a way we can somehow run your example or code.
+        - To create a shareable example, consider cloning the following Foam Github template: https://github.com/foambubble/foam-template
+        - Please read these tips for providing a minimal example: https://stackoverflow.com/help/mcve.
+      placeholder: |
+        e.g. Link to your github repository containing a small reproducible example that the team can run.
+    validations:
+      required: false
+  - type: textarea
+    id: steps
+    attributes:
+      label: Steps to Reproduce the Bug or Issue
+      description: Describe the steps we have to take to reproduce the behavior.
+      placeholder: |
+        1. Go to '...'
+        2. Click on '....'
+        3. Scroll down to '....'
+        4. See error
+    validations:
+      required: true
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected behavior
+      description: Provide a clear and concise description of what you expected to happen.
+      placeholder: |
+        As a user, I expected ___ behavior but i am seeing ___
+    validations:
+      required: true
+  - type: textarea
+    id: screenshots_or_videos
+    attributes:
+      label: Screenshots or Videos
+      description: |
+        If applicable, add screenshots or a video to help explain your problem.
+        For more information on the supported file image/file types and the file size limits, please refer
+        to the following link: https://docs.github.com/en/github/writing-on-github/working-with-advanced-formatting/attaching-files
+      placeholder: |
+        You can drag your video or image files inside of this editor ↓
+  - type: input
+    id: os
+    attributes:
+      label: Operating System Version
+      description: What opearting system are you using?
+      placeholder: |
+        - OS: [e.g. macOS, Windows, Linux]
+    validations:
+      required: true
+  - type: input
+    id: vscode_version 
+    attributes:
+      label: Visual Studio Code Version
+      description: |
+        What version of Visual Studio Code are you using?
+        How to find Visual Studio Code Version: https://code.visualstudio.com/docs/supporting/FAQ#_how-do-i-find-the-version
+    validations:
+      required: true
+  - type: textarea
+    id: additional
+    attributes:
+      label: Additional context
+      description: | 
+        Add any other context about the problem here.
+        The Foam log output for VSCode can be found here: https://github.com/foambubble/foam/blob/master/docs/features/foam-logging-in-vscode.md

.github/ISSUE_TEMPLATE/feature.md

@@ -1,6 +0,0 @@
----
-name: Feature request
-about: Suggest an idea to help us be foamier
----
-
-<!-- Describe the feature you'd like. -->

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,42 @@
+name: Feature request
+description: Suggest an idea for the `Foam` project
+body:
+  - type: markdown
+    attributes:
+      value: |
+        This issue form is for requesting features only!
+        If you want to report a bug, please use the [bug report](https://github.com/foambubble/foam/issues/new?assignees=&labels=&template=bug_report.yml) form.
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: Is your feature request related to a problem? Please describe.
+      description: A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: Describe the solution you'd like
+      description: A clear and concise description of what you want to happen.
+      placeholder: |
+        As a user, I expected ___ behavior but ___ ...
+        
+        Ideal Steps I would like to see:
+        1. Go to '...'
+        2. Click on '....'
+        3. ....
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: Describe alternatives you've considered
+      description: A clear and concise description of any alternative solutions or features you've considered.
+  - type: textarea
+    attributes:
+      label: Screenshots or Videos
+      description: |
+        If applicable, add screenshots or a video to help explain your problem.
+        For more information on the supported file image/file types and the file size limits, please refer
+        to the following link: https://docs.github.com/en/github/writing-on-github/working-with-advanced-formatting/attaching-files
+      placeholder: |
+        You can drag your video or image files inside of this editor ↓

.gitignore

@@ -9,3 +9,4 @@ dist
 docs/_site
 docs/.sass-cache
 docs/.jekyll-metadata
+.test-workspace

.vscode/launch.json

@@ -6,15 +6,20 @@
   "version": "0.2.0",
   "configurations": [
     {
-      "type": "node",
       "name": "Debug Jest Tests",
+      "type": "extensionHost",
       "request": "launch",
-      "runtimeArgs": ["workspace", "foam-vscode", "run", "test"], // ${yarnWorkspaceName} is what we're missing
-      "args": ["--runInBand"],
-      "runtimeExecutable": "yarn",
-      "console": "integratedTerminal",
-      "internalConsoleOptions": "neverOpen",
-      "disableOptimisticBPs": true
+      "args": [
+        "${workspaceFolder}/packages/foam-vscode/.test-workspace",
+        "--disable-extensions",
+        "--disable-workspace-trust",
+        "--extensionDevelopmentPath=${workspaceFolder}/packages/foam-vscode",
+        "--extensionTestsPath=${workspaceFolder}/packages/foam-vscode/out/test/suite"
+      ],
+      "outFiles": [
+        "${workspaceFolder}/packages/foam-vscode/out/**/*.js"
+      ],
+      "preLaunchTask": "${defaultBuildTask}"
     },
     {
       "name": "Run VSCode Extension",
@@ -24,8 +29,25 @@
       "args": [
         "--extensionDevelopmentPath=${workspaceFolder}/packages/foam-vscode"
       ],
-      "outFiles": ["${workspaceFolder}/packages/foam-vscode/out/**/*.js"],
+      "outFiles": [
+        "${workspaceFolder}/packages/foam-vscode/out/**/*.js"
+      ],
       "preLaunchTask": "${defaultBuildTask}"
+    },
+    {
+      "type": "node",
+      "name": "vscode-jest-tests",
+      "request": "launch",
+      "console": "integratedTerminal",
+      "internalConsoleOptions": "neverOpen",
+      "disableOptimisticBPs": true,
+      "cwd": "${workspaceFolder}/packages/foam-vscode",
+      "runtimeExecutable": "yarn",
+      "args": [
+        "jest",
+        "--runInBand",
+        "--watchAll=false"
+      ]
     }
   ]
 }

.vscode/settings.json

@@ -20,13 +20,13 @@
     "**/node_modules/**/*",
     "packages/**/*"
   ],
-  "editor.defaultFormatter": "esbenp.prettier-vscode",
-  "prettier.requireConfig": true,
-  "editor.formatOnSave": true,
   "editor.tabSize": 2,
-  "jest.debugCodeLens.showWhenTestStateIn": ["fail", "unknown", "pass"],
+  "editor.formatOnSave": true,
+  "editor.formatOnSaveMode": "file",
+  "editor.defaultFormatter": "esbenp.prettier-vscode",
+  "jest.autoRun": "off",
+  "jest.rootPath": "packages/foam-vscode",
+  "jest.jestCommandLine": "yarn jest",
   "gitdoc.enabled": false,
-  "jest.autoEnable": false,
-  "jest.runAllTestsFirst": false,
   "search.mode": "reuseEditor"
 }

.yarnrc

@@ -0,0 +1 @@
+--ignore-engines true

docs/features/backlinking.md

@@ -1,6 +1,6 @@
 # Backlinking
 
-When using [[wikilinks]], you can find all notes that link to a specific note in the [VS Code Markdown Notes](https://marketplace.visualstudio.com/items?itemName=kortina.vscode-markdown-notes) **Backlinks Explorer**
+When using [[wikilinks]], you can find all notes that link to a specific note in the **Backlinks Explorer**
 
 - Run `Cmd` + `Shift` + `P` (`Ctrl` + `Shift` + `P` for Windows), type "backlinks" and run the **Explorer: Focus on Backlinks** view.
 - Keep this pane always visible to discover relationships between your thoughts

docs/features/note-templates.md

@@ -45,10 +45,9 @@ In addition, you can also use variables provided by Foam:
 | -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `FOAM_SELECTED_TEXT` | Foam will fill it with selected text when creating a new note, if any text is selected. Selected text will be replaced with a wikilink to the new note.                                                                     |
 | `FOAM_TITLE`         | The title of the note. If used, Foam will prompt you to enter a title for the note.                                                                                                                                         |
+| `FOAM_SLUG`          | The sluggified title of the note (using the default github slug method). If used, Foam will prompt you to enter a title for the note unless `FOAM_TITLE` has already caused the prompt.                                     |
 | `FOAM_DATE_*`        | `FOAM_DATE_YEAR`, `FOAM_DATE_MONTH`, etc. Foam-specific versions of [VS Code's datetime snippet variables](https://code.visualstudio.com/docs/editor/userdefinedsnippets#_variables). Prefer these versions over VS Code's. |
 
-**Note:** neither the defaulting feature (eg. `${variable:default}`) nor the format feature (eg. `${variable/(.*)/${1:/upcase}/}`) (available to other variables) are available for these Foam-provided variables. See [#693](https://github.com/foambubble/foam/issues/693).
-
 ### `FOAM_DATE_*` variables
 
 Foam defines its own set of datetime variables that have a similar behaviour as [VS Code's datetime snippet variables](https://code.visualstudio.com/docs/editor/userdefinedsnippets#_variables).

docs/index.md

@@ -220,6 +220,15 @@ If that sounds like something you're interested in, I'd love to have you along o
     <td align="center"><a href="https://github.com/AndreiD049"><img src="https://avatars.githubusercontent.com/u/52671223?v=4?s=60" width="60px;" alt=""/><br /><sub><b>AndreiD049</b></sub></a><br /><a href="https://github.com/foambubble/foam/commits?author=AndreiD049" title="Code">💻</a></td>
     <td align="center"><a href="https://github.com/iam-yan"><img src="https://avatars.githubusercontent.com/u/48427014?v=4?s=60" width="60px;" alt=""/><br /><sub><b>Yan</b></sub></a><br /><a href="https://github.com/foambubble/foam/commits?author=iam-yan" title="Documentation">📖</a></td>
     <td align="center"><a href="https://WikiEducator.org/User:JimTittsler"><img src="https://avatars.githubusercontent.com/u/180326?v=4?s=60" width="60px;" alt=""/><br /><sub><b>Jim Tittsler</b></sub></a><br /><a href="https://github.com/foambubble/foam/commits?author=jimt" title="Documentation">📖</a></td>
+    <td align="center"><a href="http://malcolmmielle.wordpress.com/"><img src="https://avatars.githubusercontent.com/u/4457840?v=4?s=60" width="60px;" alt=""/><br /><sub><b>Malcolm Mielle</b></sub></a><br /><a href="https://github.com/foambubble/foam/commits?author=MalcolmMielle" title="Documentation">📖</a></td>
+    <td align="center"><a href="https://snippets.page/"><img src="https://avatars.githubusercontent.com/u/74916913?v=4?s=60" width="60px;" alt=""/><br /><sub><b>Veesar</b></sub></a><br /><a href="https://github.com/foambubble/foam/commits?author=veesar" title="Documentation">📖</a></td>
+    <td align="center"><a href="https://github.com/bentongxyz"><img src="https://avatars.githubusercontent.com/u/60358804?v=4?s=60" width="60px;" alt=""/><br /><sub><b>bentongxyz</b></sub></a><br /><a href="https://github.com/foambubble/foam/commits?author=bentongxyz" title="Code">💻</a></td>
+    <td align="center"><a href="https://brianjdevries.com"><img src="https://avatars.githubusercontent.com/u/42778030?v=4?s=60" width="60px;" alt=""/><br /><sub><b>Brian DeVries</b></sub></a><br /><a href="https://github.com/foambubble/foam/commits?author=techCarpenter" title="Code">💻</a></td>
+  </tr>
+  <tr>
+    <td align="center"><a href="http://Cliffordfajardo.com"><img src="https://avatars.githubusercontent.com/u/6743796?v=4?s=60" width="60px;" alt=""/><br /><sub><b>Clifford Fajardo </b></sub></a><br /><a href="#tool-cliffordfajardo" title="Tools">🔧</a></td>
+    <td align="center"><a href="http://cu-dev.ca"><img src="https://avatars.githubusercontent.com/u/6589365?v=4?s=60" width="60px;" alt=""/><br /><sub><b>Chris Usick</b></sub></a><br /><a href="https://github.com/foambubble/foam/commits?author=chrisUsick" title="Code">💻</a></td>
+    <td align="center"><a href="https://github.com/josephdecock"><img src="https://avatars.githubusercontent.com/u/1145533?v=4?s=60" width="60px;" alt=""/><br /><sub><b>Joe DeCock</b></sub></a><br /><a href="https://github.com/foambubble/foam/commits?author=josephdecock" title="Code">💻</a></td>
   </tr>
 </table>
 

docs/publishing/publish-to-github-pages.md

@@ -1,10 +1,10 @@
 # GitHub Pages
 
-- In VSCode workspace settings set `"foam.edit.linkReferenceDefinitions": "withoutExtensions"`
-- Execute the “Foam: Run Janitor” command from the command palette.
-- [Turn **GitHub Pages** on in your repository settings](https://guides.github.com/features/pages/).
-- The default GitHub Pages template is called [Primer](https://github.com/pages-themes/primer). See Primer docs for how to customise html layouts and templates.
-- GitHub Pages is built on [Jekyll](https://jekyllrb.com/), so it supports things like permalinks, front matter metadata etc.
+1. In VSCode workspace settings set `"foam.edit.linkReferenceDefinitions": "withoutExtensions"`
+2. Execute the “Foam: Run Janitor” command from the command palette.
+3. [Turn **GitHub Pages** on in your repository settings](https://guides.github.com/features/pages/).
+   - The default GitHub Pages template is called [Primer](https://github.com/pages-themes/primer). See Primer docs for how to customise html layouts and templates.
+   - GitHub Pages is built on [Jekyll](https://jekyllrb.com/), so it supports things like permalinks, front matter metadata etc.
 
 ## How to publish locally
 

docs/publishing/publish-to-gitlab-pages.md

@@ -2,13 +2,175 @@
 
 You don't have to use GitHub to serve Foam pages. You can also use GitLab.
 
+Gitlab pages can be kept private for private repo, so that your notes are still private.
+
 ## Setup a project
 
 ### Generate the directory from GitHub
 
-Generate a solution using the [Foam template].
+Generate a solution using the [Foam template](https://github.com/foambubble/foam-template).
 
-Change the remote to GitLab, or copy all the files into a new GitLab repo.
+Change the remote to GitLab, or copy all the files into a new GitLab repo
+
+## Publishing pages with Gatsby
+
+### Setup the Gatsby config
+
+Add a .gatsby-config.js file where:
+
+* `$REPO_NAME` correspond to the name of your gtlab repo.
+* `$USER_NAME` correspond to your gitlab username.
+
+```js
+const path = require("path");
+const pathPrefix = `/$REPO_NAME`;
+
+// Change me
+const siteMetadata = {
+  title: "A title",
+  shortName: "A short name",
+  description: "",
+  imageUrl: "/graph-visualisation.jpg",
+  siteUrl: "https://$USER_NAME.gitlab.io",
+};
+module.exports = {
+  siteMetadata,
+  pathPrefix,
+  flags: {
+    DEV_SSR: true,
+  },
+  plugins: [
+    `gatsby-plugin-sharp`,
+    {
+      resolve: "gatsby-theme-primer-wiki",
+      options: {
+        defaultColorMode: "night",
+        icon: "./path_to/logo.png",
+        sidebarComponents: ["tag", "category"],
+        nav: [
+          {
+            title: "Github",
+            url: "https://github.com/$USER_NAME/",
+          },
+          {
+            title: "Gitlab",
+            url: "https://gitlab.com/$USER_NAME/",
+          },
+        ],
+        editUrl:
+          "https://gitlab.com/$USER_NAME/$REPO_NAME/tree/main/",
+      },
+    },
+    {
+      resolve: "gatsby-source-filesystem",
+      options: {
+        name: "content",
+        path: `${__dirname}`,
+        ignore: [`**/\.*/**/*`],
+      },
+    },
+
+    {
+      resolve: "gatsby-plugin-manifest",
+      options: {
+        name: siteMetadata.title,
+        short_name: siteMetadata.shortName,
+        start_url: pathPrefix,
+        background_color: `#f7f0eb`,
+        display: `standalone`,
+        icon: path.resolve(__dirname, "./path_to/logo.png"),
+      },
+    },
+    {
+      resolve: `gatsby-plugin-sitemap`,
+    },
+    {
+      resolve: "gatsby-plugin-robots-txt",
+      options: {
+        host: siteMetadata.siteUrl,
+        sitemap: `${siteMetadata.siteUrl}/sitemap/sitemap-index.xml`,
+        policy: [{ userAgent: "*", allow: "/" }],
+      },
+    },
+  ],
+};
+```
+
+And a `package.json` file containing:
+
+```json
+{
+    "private": true,
+    "name": "wiki",
+    "version": "1.0.0",
+    "license": "MIT",
+    "scripts": {
+        "develop": "gatsby develop -H 0.0.0.0",
+        "start": "gatsby develop -H 0.0.0.0",
+        "build": "gatsby build",
+        "clean": "gatsby clean",
+        "serve": "gatsby serve",
+        "test": "echo test"
+    },
+    "dependencies": {
+        "@primer/react": "^34.1.0",
+        "@primer/css": "^17.5.0",
+        "foam-cli": "^0.11.0",
+        "gatsby": "^3.12.0",
+        "gatsby-plugin-manifest": "^3.12.0",
+        "gatsby-plugin-robots-txt": "^1.6.9",
+        "gatsby-plugin-sitemap": "^5.4.0",
+        "gatsby-source-filesystem": "^3.12.0",
+        "gatsby-theme-primer-wiki": "^1.14.5",
+        "react": "^17.0.2",
+        "react-dom": "^17.0.2"
+    }
+}
+```
+
+The theme will be based on [gatsby-theme-primer-wiki](https://github.com/theowenyoung/gatsby-theme-primer-wiki).
+
+To test the theme locally first run `yarn install` and then use `gatsby develop` to serve the website.
+See gatsby documentation for more details.
+
+### Set-up the CI for deployment
+
+Create a `.gitlab-ci.yml` file containing:
+
+```yml
+# To contribute improvements to CI/CD templates, please follow the Development guide at:
+# https://docs.gitlab.com/ee/development/cicd/templates.html
+# This specific template is located at:
+# https://gitlab.com/gitlab-org/gitlab/-/blob/master/lib/gitlab/ci/templates/Pages/Gatsby.gitlab-ci.yml
+
+image: node:latest
+
+stages:
+  - deploy
+
+pages:
+  stage: deploy
+  # This folder is cached between builds
+  # https://docs.gitlab.com/ee/ci/yaml/index.html#cache
+  cache:
+    paths:
+      - node_modules/
+      # Enables git-lab CI caching. Both .cache and public must be cached, otherwise builds will fail.
+      - .cache/
+      - public/
+  script:
+    - yarn install
+    - ./node_modules/.bin/gatsby build --prefix-paths
+  artifacts:
+    paths:
+      - public
+  rules:
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+```
+
+This pipeline will now serve your website on every push to the main branch of your project.
+
+## Publish with Jekyll
 
 ### Add a _config.yaml
 
@@ -47,14 +209,14 @@ gem "jekyll-optional-front-matter"
 
 Commit the file and push it to gitlab.
 
-## Setup CI/CD
+### Setup CI/CD
 
 1. From the project home in GitLab click `Set up CI/CD`
 2. Choose `Jekyll` as your template from the template dropdown
 3. Click `commit`
 4. Now when you go to CI / CD > Pipelines, you should see the code running
 
-## Troubleshooting
+### Troubleshooting
 
 - *Could not locate Gemfile* - You didn't follow the steps above to [#Add a Gemlock file]
 - *Conversion error: Jekyll::Converters::Scss encountered an error while converting* You need to reference a theme.

docs/recipes/diagrams-in-markdown.md

@@ -11,8 +11,6 @@ We have two alternative #recipe for displaying diagrams in markdown:
 
 You can use [Mermaid](https://marketplace.visualstudio.com/items?itemName=bierner.markdown-mermaid) plugin to draw and preview diagrams in your content.
 
-⚠️ Be aware that Mermaid diagrams don't automatically get rendered in published Foams in [[publish-to-github-pages]], and would require you to eject to another static site generation approach that supports Mermaid plugins.
-
 ## Draw.io
 
 [Draw.io](https://marketplace.visualstudio.com/items?itemName=hediet.vscode-drawio) extension allows you to create, edit, and display your diagrams without leaving Visual Studio Code. The `.drawio.svg` or `.drawio.png` files can be automatically embedded and displayed in published Foams, no export needed. FYI, the diagram below was made using Draw.io! You can check the diagram [here](../assets/images/diagram-drawio-demo.drawio.svg).

docs/recipes/web-clipper.md

@@ -9,3 +9,6 @@ There are a couple of options when it comes to clipping web pages:
 
 - [Markdown Clipper](https://github.com/deathau/markdownload)
   - A Firefox and Google Chrome extension to clip websites and download them into a readable markdown file.
+
+- [Web Clipper](https://clipper.website/)
+  - A Firefox, Chrome and Edge extension to clip websites and save them directly to the GitHub repository into a readable markdown file.

lerna.json

@@ -4,5 +4,5 @@
   ],
   "npmClient": "yarn",
   "useWorkspaces": true,
-  "version": "0.17.1"
+  "version": "0.18.2"
 }

packages/foam-vscode/CHANGELOG.md

@@ -4,6 +4,73 @@ 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.2] - 2022-04-14
+
+Fixes and Improvements:
+- Fixed parsing error on empty direct links (#980 - thanks @chrisUsick)
+- Improved rendering in preview of wikilinks that have link definitions (#979 - thanks @josephdecock)
+- Restored handling of section-only wikilinks (#981)
+
+## [0.18.1] - 2022-04-13
+
+Fixes and Improvements:
+- Fixed parsing error for direct links with square brackets in them (#977)
+- Improved markdown direct link resolution (#972)
+- Improved templates support for custom paths (#970)
+
+## [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:
+- Don't fail on error when scannig workspace (#943 - thanks @develmusa)
+
+## [0.17.5] - 2022-02-22
+
+Fixes and Improvements:
+- Added FOAM_SLUG template variable (#865 - Thanks @techCarpenter)
+
+## [0.17.4] - 2022-02-13
+
+Fixes and Improvements:
+- Improvements to Foam variables in templates (#882 - thanks @movermeyer)
+  - Foam variables can now be used just any other VS Code variables, including in combination with placeholders and transformers
+
+## [0.17.3] - 2022-01-14
+
+Fixes and Improvements:
+- Fixed autocompletion with tags (#885 - thanks @memeplex)
+- Improved "Open Daily Note" to be usabled in tasks (#897 - thanks @MCluck90)
+
+## [0.17.2] - 2021-12-22
+
+Fixes and Improvements:
+- Improved support for wikilinks in titles (#878)
+- Use syntax injection for wikilinks (#876 - thanks @memeplex)
+- Fix when applying text edits in last line 
+
+Internal:
+- DX: Clean up of testing setup (#881 - thanks @memeplex)
+
 ## [0.17.1] - 2021-12-16
 
 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/babel.config.js

@@ -1,7 +0,0 @@
-module.exports = {
-  presets: [
-    ["@babel/preset-env", { targets: { node: "current" } }],
-    "@babel/preset-typescript"
-  ],
-  plugins: [["@babel/plugin-transform-runtime", { helpers: false }]]
-};

packages/foam-vscode/jest.config.js

@@ -82,7 +82,7 @@ module.exports = {
   // moduleNameMapper: {},
 
   // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
-  // modulePathIgnorePatterns: [],
+  modulePathIgnorePatterns: ['.vscode-test'],
 
   // Activates notifications for test results
   // notify: false,
@@ -91,7 +91,7 @@ module.exports = {
   // notifyMode: "failure-change",
 
   // A preset that is used as a base for Jest's configuration
-  // preset: undefined,
+  preset: 'ts-jest',
 
   // Run tests from one or more projects
   // projects: undefined,
@@ -126,13 +126,13 @@ module.exports = {
   // setupFiles: [],
 
   // A list of paths to modules that run some code to configure or set up the testing framework before each test
-  // setupFilesAfterEnv: [],
+  setupFilesAfterEnv: ['jest-extended'],
 
   // A list of paths to snapshot serializer modules Jest should use for snapshot testing
   // snapshotSerializers: [],
 
   // The test environment that will be used for testing
-  testEnvironment: "node"
+  testEnvironment: 'node',
 
   // Options that will be passed to the testEnvironment
   // testEnvironmentOptions: {},
@@ -152,7 +152,10 @@ module.exports = {
   // ],
 
   // The regexp pattern or array of patterns that Jest uses to detect test files
-  // testRegex: [],
+  // This is overridden in every runCLI invocation but it's here as the default
+  // for vscode-jest. We only want unit tests in the test explorer (sidebar),
+  // since spec tests require the entire extension host to be launched before.
+  testRegex: ['\\.test\\.ts$'],
 
   // This option allows the use of a custom results processor
   // testResultsProcessor: undefined,

packages/foam-vscode/package.json

@@ -8,7 +8,7 @@
     "type": "git"
   },
   "homepage": "https://github.com/foambubble/foam",
-  "version": "0.17.1",
+  "version": "0.18.2",
   "license": "MIT",
   "publisher": "foam",
   "engines": {
@@ -37,6 +37,26 @@
     "markdown.previewStyles": [
       "./static/preview/style.css"
     ],
+    "grammars": [
+      {
+        "path": "./syntaxes/injection.json",
+        "scopeName": "foam.wikilink.injection",
+        "injectTo": [
+          "text.html.markdown"
+        ]
+      }
+    ],
+    "colors": [
+      {
+        "id": "foam.placeholder",
+        "description": "Color of foam placeholders.",
+        "defaults": {
+          "dark": "editorWarning.foreground",
+          "light": "editorWarning.foreground",
+          "highContrast": "editorWarning.foreground"
+        }
+      }
+    ],
     "views": {
       "explorer": [
         {
@@ -235,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",
@@ -356,7 +381,9 @@
     "build": "tsc -p ./",
     "pretest": "yarn build",
     "test": "node ./out/test/run-tests.js",
+    "pretest:unit": "yarn build",
     "test:unit": "node ./out/test/run-tests.js --unit",
+    "pretest:e2e": "yarn build",
     "test:e2e": "node ./out/test/run-tests.js --e2e",
     "lint": "tsdx lint src",
     "clean": "rimraf out",
@@ -372,12 +399,7 @@
     "publish-extension": "yarn publish-extension-vscode && yarn publish-extension-openvsx && yarn npm-cleanup"
   },
   "devDependencies": {
-    "@babel/core": "^7.11.0",
-    "@babel/plugin-transform-runtime": "^7.10.4",
-    "@babel/preset-env": "^7.11.0",
-    "@babel/preset-typescript": "^7.10.4",
     "@types/dateformat": "^3.0.1",
-    "@types/github-slugger": "^1.3.0",
     "@types/glob": "^7.1.1",
     "@types/lodash": "^4.14.157",
     "@types/markdown-it": "^12.0.1",
@@ -388,12 +410,12 @@
     "@types/vscode": "^1.47.1",
     "@typescript-eslint/eslint-plugin": "^2.30.0",
     "@typescript-eslint/parser": "^2.30.0",
-    "babel-jest": "^26.2.2",
     "eslint": "^6.8.0",
+    "eslint-import-resolver-typescript": "^2.5.0",
     "eslint-plugin-import": "^2.24.2",
+    "eslint-plugin-jest": "^25.3.0",
     "husky": "^4.2.5",
     "jest": "^26.2.2",
-    "jest-environment-vscode": "^1.0.0",
     "jest-extended": "^0.11.5",
     "markdown-it": "^12.0.4",
     "rimraf": "^3.0.2",
@@ -401,13 +423,14 @@
     "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",
     "detect-newline": "^3.1.0",
     "fast-array-diff": "^1.0.1",
-    "github-slugger": "^1.3.0",
+    "github-slugger": "^1.4.0",
     "glob": "^7.1.6",
     "gray-matter": "^4.0.2",
     "lodash": "^4.17.21",

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

@@ -0,0 +1,811 @@
+/*---------------------------------------------------------------------------------------------
+ *  Originally taken from https://github.com/microsoft/vscode/blob/d31496c866683bdbccfc85bc11a3107d6c789b52/src/vs/editor/contrib/snippet/test/snippetParser.test.ts
+ *  Here was the license:
+ *
+ *  MIT License
+ *
+ *	Copyright (c) 2015 - present Microsoft Corporation
+ *
+ *	Permission is hereby granted, free of charge, to any person obtaining a copy
+ *	of this software and associated documentation files (the "Software"), to deal
+ *	in the Software without restriction, including without limitation the rights
+ *	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *	copies of the Software, and to permit persons to whom the Software is
+ *	furnished to do so, subject to the following conditions:
+ *
+ *	The above copyright notice and this permission notice shall be included in all
+ *	copies or substantial portions of the Software.
+ *
+ *	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *	SOFTWARE.
+ *
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import { Choice, FormatString, Marker, Placeholder, Scanner, SnippetParser, Text, TextmateSnippet, TokenType, Transform, Variable } from './snippetParser';
+
+describe('SnippetParser', () => {
+
+	test('Scanner', () => {
+
+		const scanner = new Scanner();
+		assert.strictEqual(scanner.next().type, TokenType.EOF);
+
+		scanner.text('abc');
+		assert.strictEqual(scanner.next().type, TokenType.VariableName);
+		assert.strictEqual(scanner.next().type, TokenType.EOF);
+
+		scanner.text('{{abc}}');
+		assert.strictEqual(scanner.next().type, TokenType.CurlyOpen);
+		assert.strictEqual(scanner.next().type, TokenType.CurlyOpen);
+		assert.strictEqual(scanner.next().type, TokenType.VariableName);
+		assert.strictEqual(scanner.next().type, TokenType.CurlyClose);
+		assert.strictEqual(scanner.next().type, TokenType.CurlyClose);
+		assert.strictEqual(scanner.next().type, TokenType.EOF);
+
+		scanner.text('abc() ');
+		assert.strictEqual(scanner.next().type, TokenType.VariableName);
+		assert.strictEqual(scanner.next().type, TokenType.Format);
+		assert.strictEqual(scanner.next().type, TokenType.EOF);
+
+		scanner.text('abc 123');
+		assert.strictEqual(scanner.next().type, TokenType.VariableName);
+		assert.strictEqual(scanner.next().type, TokenType.Format);
+		assert.strictEqual(scanner.next().type, TokenType.Int);
+		assert.strictEqual(scanner.next().type, TokenType.EOF);
+
+		scanner.text('$foo');
+		assert.strictEqual(scanner.next().type, TokenType.Dollar);
+		assert.strictEqual(scanner.next().type, TokenType.VariableName);
+		assert.strictEqual(scanner.next().type, TokenType.EOF);
+
+		scanner.text('$foo_bar');
+		assert.strictEqual(scanner.next().type, TokenType.Dollar);
+		assert.strictEqual(scanner.next().type, TokenType.VariableName);
+		assert.strictEqual(scanner.next().type, TokenType.EOF);
+
+		scanner.text('$foo-bar');
+		assert.strictEqual(scanner.next().type, TokenType.Dollar);
+		assert.strictEqual(scanner.next().type, TokenType.VariableName);
+		assert.strictEqual(scanner.next().type, TokenType.Dash);
+		assert.strictEqual(scanner.next().type, TokenType.VariableName);
+		assert.strictEqual(scanner.next().type, TokenType.EOF);
+
+		scanner.text('${foo}');
+		assert.strictEqual(scanner.next().type, TokenType.Dollar);
+		assert.strictEqual(scanner.next().type, TokenType.CurlyOpen);
+		assert.strictEqual(scanner.next().type, TokenType.VariableName);
+		assert.strictEqual(scanner.next().type, TokenType.CurlyClose);
+		assert.strictEqual(scanner.next().type, TokenType.EOF);
+
+		scanner.text('${1223:foo}');
+		assert.strictEqual(scanner.next().type, TokenType.Dollar);
+		assert.strictEqual(scanner.next().type, TokenType.CurlyOpen);
+		assert.strictEqual(scanner.next().type, TokenType.Int);
+		assert.strictEqual(scanner.next().type, TokenType.Colon);
+		assert.strictEqual(scanner.next().type, TokenType.VariableName);
+		assert.strictEqual(scanner.next().type, TokenType.CurlyClose);
+		assert.strictEqual(scanner.next().type, TokenType.EOF);
+
+		scanner.text('\\${}');
+		assert.strictEqual(scanner.next().type, TokenType.Backslash);
+		assert.strictEqual(scanner.next().type, TokenType.Dollar);
+		assert.strictEqual(scanner.next().type, TokenType.CurlyOpen);
+		assert.strictEqual(scanner.next().type, TokenType.CurlyClose);
+
+		scanner.text('${foo/regex/format/option}');
+		assert.strictEqual(scanner.next().type, TokenType.Dollar);
+		assert.strictEqual(scanner.next().type, TokenType.CurlyOpen);
+		assert.strictEqual(scanner.next().type, TokenType.VariableName);
+		assert.strictEqual(scanner.next().type, TokenType.Forwardslash);
+		assert.strictEqual(scanner.next().type, TokenType.VariableName);
+		assert.strictEqual(scanner.next().type, TokenType.Forwardslash);
+		assert.strictEqual(scanner.next().type, TokenType.VariableName);
+		assert.strictEqual(scanner.next().type, TokenType.Forwardslash);
+		assert.strictEqual(scanner.next().type, TokenType.VariableName);
+		assert.strictEqual(scanner.next().type, TokenType.CurlyClose);
+		assert.strictEqual(scanner.next().type, TokenType.EOF);
+	});
+
+	function assertText(value: string, expected: string) {
+		const p = new SnippetParser();
+		const actual = p.text(value);
+		assert.strictEqual(actual, expected);
+	}
+
+	function assertMarker(input: TextmateSnippet | Marker[] | string, ...ctors: Function[]) {
+		let marker: Marker[];
+		if (input instanceof TextmateSnippet) {
+			marker = input.children;
+		} else if (typeof input === 'string') {
+			const p = new SnippetParser();
+			marker = p.parse(input).children;
+		} else {
+			marker = input;
+		}
+		while (marker.length > 0) {
+			let m = marker.pop();
+			let ctor = ctors.pop()!;
+			assert.ok(m instanceof ctor);
+		}
+		assert.strictEqual(marker.length, ctors.length);
+		assert.strictEqual(marker.length, 0);
+	}
+
+	function assertTextAndMarker(value: string, escaped: string, ...ctors: Function[]) {
+		assertText(value, escaped);
+		assertMarker(value, ...ctors);
+	}
+
+	function assertEscaped(value: string, expected: string) {
+		const actual = SnippetParser.escape(value);
+		assert.strictEqual(actual, expected);
+	}
+
+	test('Parser, escaped', function () {
+		assertEscaped('foo$0', 'foo\\$0');
+		assertEscaped('foo\\$0', 'foo\\\\\\$0');
+		assertEscaped('f$1oo$0', 'f\\$1oo\\$0');
+		assertEscaped('${1:foo}$0', '\\${1:foo\\}\\$0');
+		assertEscaped('$', '\\$');
+	});
+
+	test('Parser, text', () => {
+		assertText('$', '$');
+		assertText('\\\\$', '\\$');
+		assertText('{', '{');
+		assertText('\\}', '}');
+		assertText('\\abc', '\\abc');
+		assertText('foo${f:\\}}bar', 'foo}bar');
+		assertText('\\{', '\\{');
+		assertText('I need \\\\\\$', 'I need \\$');
+		assertText('\\', '\\');
+		assertText('\\{{', '\\{{');
+		assertText('{{', '{{');
+		assertText('{{dd', '{{dd');
+		assertText('}}', '}}');
+		assertText('ff}}', 'ff}}');
+
+		assertText('farboo', 'farboo');
+		assertText('far{{}}boo', 'far{{}}boo');
+		assertText('far{{123}}boo', 'far{{123}}boo');
+		assertText('far\\{{123}}boo', 'far\\{{123}}boo');
+		assertText('far{{id:bern}}boo', 'far{{id:bern}}boo');
+		assertText('far{{id:bern {{basel}}}}boo', 'far{{id:bern {{basel}}}}boo');
+		assertText('far{{id:bern {{id:basel}}}}boo', 'far{{id:bern {{id:basel}}}}boo');
+		assertText('far{{id:bern {{id2:basel}}}}boo', 'far{{id:bern {{id2:basel}}}}boo');
+	});
+
+
+	test('Parser, TM text', () => {
+		assertTextAndMarker('foo${1:bar}}', 'foobar}', Text, Placeholder, Text);
+		assertTextAndMarker('foo${1:bar}${2:foo}}', 'foobarfoo}', Text, Placeholder, Placeholder, Text);
+
+		assertTextAndMarker('foo${1:bar\\}${2:foo}}', 'foobar}foo', Text, Placeholder);
+
+		let [, placeholder] = new SnippetParser().parse('foo${1:bar\\}${2:foo}}').children;
+		let { children } = (<Placeholder>placeholder);
+
+		assert.strictEqual((<Placeholder>placeholder).index, 1);
+		assert.ok(children[0] instanceof Text);
+		assert.strictEqual(children[0].toString(), 'bar}');
+		assert.ok(children[1] instanceof Placeholder);
+		assert.strictEqual(children[1].toString(), 'foo');
+	});
+
+	test('Parser, placeholder', () => {
+		assertTextAndMarker('farboo', 'farboo', Text);
+		assertTextAndMarker('far{{}}boo', 'far{{}}boo', Text);
+		assertTextAndMarker('far{{123}}boo', 'far{{123}}boo', Text);
+		assertTextAndMarker('far\\{{123}}boo', 'far\\{{123}}boo', Text);
+	});
+
+	test('Parser, literal code', () => {
+		assertTextAndMarker('far`123`boo', 'far`123`boo', Text);
+		assertTextAndMarker('far\\`123\\`boo', 'far\\`123\\`boo', Text);
+	});
+
+	test('Parser, variables/tabstop', () => {
+		assertTextAndMarker('$far-boo', '-boo', Variable, Text);
+		assertTextAndMarker('\\$far-boo', '$far-boo', Text);
+		assertTextAndMarker('far$farboo', 'far', Text, Variable);
+		assertTextAndMarker('far${farboo}', 'far', Text, Variable);
+		assertTextAndMarker('$123', '', Placeholder);
+		assertTextAndMarker('$farboo', '', Variable);
+		assertTextAndMarker('$far12boo', '', Variable);
+		assertTextAndMarker('000_${far}_000', '000__000', Text, Variable, Text);
+		assertTextAndMarker('FFF_${TM_SELECTED_TEXT}_FFF$0', 'FFF__FFF', Text, Variable, Text, Placeholder);
+	});
+
+	test('Parser, variables/placeholder with defaults', () => {
+		assertTextAndMarker('${name:value}', 'value', Variable);
+		assertTextAndMarker('${1:value}', 'value', Placeholder);
+		assertTextAndMarker('${1:bar${2:foo}bar}', 'barfoobar', Placeholder);
+
+		assertTextAndMarker('${name:value', '${name:value', Text);
+		assertTextAndMarker('${1:bar${2:foobar}', '${1:barfoobar', Text, Placeholder);
+	});
+
+	test('Parser, variable transforms', function () {
+		assertTextAndMarker('${foo///}', '', Variable);
+		assertTextAndMarker('${foo/regex/format/gmi}', '', Variable);
+		assertTextAndMarker('${foo/([A-Z][a-z])/format/}', '', Variable);
+
+		// invalid regex
+		assertTextAndMarker('${foo/([A-Z][a-z])/format/GMI}', '${foo/([A-Z][a-z])/format/GMI}', Text);
+		assertTextAndMarker('${foo/([A-Z][a-z])/format/funky}', '${foo/([A-Z][a-z])/format/funky}', Text);
+		assertTextAndMarker('${foo/([A-Z][a-z]/format/}', '${foo/([A-Z][a-z]/format/}', Text);
+
+		// tricky regex
+		assertTextAndMarker('${foo/m\\/atch/$1/i}', '', Variable);
+		assertMarker('${foo/regex\/format/options}', Text);
+
+		// incomplete
+		assertTextAndMarker('${foo///', '${foo///', Text);
+		assertTextAndMarker('${foo/regex/format/options', '${foo/regex/format/options', Text);
+
+		// format string
+		assertMarker('${foo/.*/${0:fooo}/i}', Variable);
+		assertMarker('${foo/.*/${1}/i}', Variable);
+		assertMarker('${foo/.*/$1/i}', Variable);
+		assertMarker('${foo/.*/This-$1-encloses/i}', Variable);
+		assertMarker('${foo/.*/complex${1:else}/i}', Variable);
+		assertMarker('${foo/.*/complex${1:-else}/i}', Variable);
+		assertMarker('${foo/.*/complex${1:+if}/i}', Variable);
+		assertMarker('${foo/.*/complex${1:?if:else}/i}', Variable);
+		assertMarker('${foo/.*/complex${1:/upcase}/i}', Variable);
+
+	});
+
+	test('Parser, placeholder transforms', function () {
+		assertTextAndMarker('${1///}', '', Placeholder);
+		assertTextAndMarker('${1/regex/format/gmi}', '', Placeholder);
+		assertTextAndMarker('${1/([A-Z][a-z])/format/}', '', Placeholder);
+
+		// tricky regex
+		assertTextAndMarker('${1/m\\/atch/$1/i}', '', Placeholder);
+		assertMarker('${1/regex\/format/options}', Text);
+
+		// incomplete
+		assertTextAndMarker('${1///', '${1///', Text);
+		assertTextAndMarker('${1/regex/format/options', '${1/regex/format/options', Text);
+	});
+
+	test('No way to escape forward slash in snippet regex #36715', function () {
+		assertMarker('${TM_DIRECTORY/src\\//$1/}', Variable);
+	});
+
+	test('No way to escape forward slash in snippet format section #37562', function () {
+		assertMarker('${TM_SELECTED_TEXT/a/\\/$1/g}', Variable);
+		assertMarker('${TM_SELECTED_TEXT/a/in\\/$1ner/g}', Variable);
+		assertMarker('${TM_SELECTED_TEXT/a/end\\//g}', Variable);
+	});
+
+	test('Parser, placeholder with choice', () => {
+
+		assertTextAndMarker('${1|one,two,three|}', 'one', Placeholder);
+		assertTextAndMarker('${1|one|}', 'one', Placeholder);
+		assertTextAndMarker('${1|one1,two2|}', 'one1', Placeholder);
+		assertTextAndMarker('${1|one1\\,two2|}', 'one1,two2', Placeholder);
+		assertTextAndMarker('${1|one1\\|two2|}', 'one1|two2', Placeholder);
+		assertTextAndMarker('${1|one1\\atwo2|}', 'one1\\atwo2', Placeholder);
+		assertTextAndMarker('${1|one,two,three,|}', '${1|one,two,three,|}', Text);
+		assertTextAndMarker('${1|one,', '${1|one,', Text);
+
+		const p = new SnippetParser();
+		const snippet = p.parse('${1|one,two,three|}');
+		assertMarker(snippet, Placeholder);
+		const expected = [Placeholder, Text, Text, Text];
+		snippet.walk(marker => {
+			assert.strictEqual(marker, expected.shift());
+			return true;
+		});
+	});
+
+	test('Snippet choices: unable to escape comma and pipe, #31521', function () {
+		assertTextAndMarker('console.log(${1|not\\, not, five, 5, 1   23|});', 'console.log(not, not);', Text, Placeholder, Text);
+	});
+
+	test('Marker, toTextmateString()', function () {
+
+		function assertTextsnippetString(input: string, expected: string): void {
+			const snippet = new SnippetParser().parse(input);
+			const actual = snippet.toTextmateString();
+			assert.strictEqual(actual, expected);
+		}
+
+		assertTextsnippetString('$1', '$1');
+		assertTextsnippetString('\\$1', '\\$1');
+		assertTextsnippetString('console.log(${1|not\\, not, five, 5, 1   23|});', 'console.log(${1|not\\, not, five, 5, 1   23|});');
+		assertTextsnippetString('console.log(${1|not\\, not, \\| five, 5, 1   23|});', 'console.log(${1|not\\, not, \\| five, 5, 1   23|});');
+		assertTextsnippetString('this is text', 'this is text');
+		assertTextsnippetString('this ${1:is ${2:nested with $var}}', 'this ${1:is ${2:nested with ${var}}}');
+		assertTextsnippetString('this ${1:is ${2:nested with $var}}}', 'this ${1:is ${2:nested with ${var}}}\\}');
+	});
+
+	test('Marker, toTextmateString() <-> identity', function () {
+
+		function assertIdent(input: string): void {
+			// full loop: (1) parse input, (2) generate textmate string, (3) parse, (4) ensure both trees are equal
+			const snippet = new SnippetParser().parse(input);
+			const input2 = snippet.toTextmateString();
+			const snippet2 = new SnippetParser().parse(input2);
+
+			function checkCheckChildren(marker1: Marker, marker2: Marker) {
+				assert.ok(marker1 instanceof Object.getPrototypeOf(marker2).constructor);
+				assert.ok(marker2 instanceof Object.getPrototypeOf(marker1).constructor);
+
+				assert.strictEqual(marker1.children.length, marker2.children.length);
+				assert.strictEqual(marker1.toString(), marker2.toString());
+
+				for (let i = 0; i < marker1.children.length; i++) {
+					checkCheckChildren(marker1.children[i], marker2.children[i]);
+				}
+			}
+
+			checkCheckChildren(snippet, snippet2);
+		}
+
+		assertIdent('$1');
+		assertIdent('\\$1');
+		assertIdent('console.log(${1|not\\, not, five, 5, 1   23|});');
+		assertIdent('console.log(${1|not\\, not, \\| five, 5, 1   23|});');
+		assertIdent('this is text');
+		assertIdent('this ${1:is ${2:nested with $var}}');
+		assertIdent('this ${1:is ${2:nested with $var}}}');
+		assertIdent('this ${1:is ${2:nested with $var}} and repeating $1');
+	});
+
+	test('Parser, choise marker', () => {
+		const { placeholders } = new SnippetParser().parse('${1|one,two,three|}');
+
+		assert.strictEqual(placeholders.length, 1);
+		assert.ok(placeholders[0].choice instanceof Choice);
+		assert.ok(placeholders[0].children[0] instanceof Choice);
+		assert.strictEqual((<Choice>placeholders[0].children[0]).options.length, 3);
+
+		assertText('${1|one,two,three|}', 'one');
+		assertText('\\${1|one,two,three|}', '${1|one,two,three|}');
+		assertText('${1\\|one,two,three|}', '${1\\|one,two,three|}');
+		assertText('${1||}', '${1||}');
+	});
+
+	test('Backslash character escape in choice tabstop doesn\'t work #58494', function () {
+
+		const { placeholders } = new SnippetParser().parse('${1|\\,,},$,\\|,\\\\|}');
+		assert.strictEqual(placeholders.length, 1);
+		assert.ok(placeholders[0].choice instanceof Choice);
+	});
+
+	test('Parser, only textmate', () => {
+		const p = new SnippetParser();
+		assertMarker(p.parse('far{{}}boo'), Text);
+		assertMarker(p.parse('far{{123}}boo'), Text);
+		assertMarker(p.parse('far\\{{123}}boo'), Text);
+
+		assertMarker(p.parse('far$0boo'), Text, Placeholder, Text);
+		assertMarker(p.parse('far${123}boo'), Text, Placeholder, Text);
+		assertMarker(p.parse('far\\${123}boo'), Text);
+	});
+
+	test('Parser, real world', () => {
+		let marker = new SnippetParser().parse('console.warn(${1: $TM_SELECTED_TEXT })').children;
+
+		assert.strictEqual(marker[0].toString(), 'console.warn(');
+		assert.ok(marker[1] instanceof Placeholder);
+		assert.strictEqual(marker[2].toString(), ')');
+
+		const placeholder = <Placeholder>marker[1];
+		assert.strictEqual(placeholder.index, 1);
+		assert.strictEqual(placeholder.children.length, 3);
+		assert.ok(placeholder.children[0] instanceof Text);
+		assert.ok(placeholder.children[1] instanceof Variable);
+		assert.ok(placeholder.children[2] instanceof Text);
+		assert.strictEqual(placeholder.children[0].toString(), ' ');
+		assert.strictEqual(placeholder.children[1].toString(), '');
+		assert.strictEqual(placeholder.children[2].toString(), ' ');
+
+		const nestedVariable = <Variable>placeholder.children[1];
+		assert.strictEqual(nestedVariable.name, 'TM_SELECTED_TEXT');
+		assert.strictEqual(nestedVariable.children.length, 0);
+
+		marker = new SnippetParser().parse('$TM_SELECTED_TEXT').children;
+		assert.strictEqual(marker.length, 1);
+		assert.ok(marker[0] instanceof Variable);
+	});
+
+	test('Parser, transform example', () => {
+		let { children } = new SnippetParser().parse('${1:name} : ${2:type}${3/\\s:=(.*)/${1:+ :=}${1}/};\n$0');
+
+		//${1:name}
+		assert.ok(children[0] instanceof Placeholder);
+		assert.strictEqual(children[0].children.length, 1);
+		assert.strictEqual(children[0].children[0].toString(), 'name');
+		assert.strictEqual((<Placeholder>children[0]).transform, undefined);
+
+		// :
+		assert.ok(children[1] instanceof Text);
+		assert.strictEqual(children[1].toString(), ' : ');
+
+		//${2:type}
+		assert.ok(children[2] instanceof Placeholder);
+		assert.strictEqual(children[2].children.length, 1);
+		assert.strictEqual(children[2].children[0].toString(), 'type');
+
+		//${3/\\s:=(.*)/${1:+ :=}${1}/}
+		assert.ok(children[3] instanceof Placeholder);
+		assert.strictEqual(children[3].children.length, 0);
+		assert.notStrictEqual((<Placeholder>children[3]).transform, undefined);
+		let transform = (<Placeholder>children[3]).transform!;
+		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);
+		assert.strictEqual((<FormatString>transform.children[0]).ifValue, ' :=');
+		assert.ok(transform.children[1] instanceof FormatString);
+		assert.strictEqual((<FormatString>transform.children[1]).index, 1);
+		assert.ok(children[4] instanceof Text);
+		assert.strictEqual(children[4].toString(), ';\n');
+
+	});
+
+	// TODO @jrieken making this strictEqul causes circular json conversion errors
+	test('Parser, default placeholder values', () => {
+
+		assertMarker('errorContext: `${1:err}`, error: $1', Text, Placeholder, Text, Placeholder);
+
+		const [, p1, , p2] = new SnippetParser().parse('errorContext: `${1:err}`, error:$1').children;
+
+		assert.strictEqual((<Placeholder>p1).index, 1);
+		assert.strictEqual((<Placeholder>p1).children.length, 1);
+		assert.strictEqual((<Text>(<Placeholder>p1).children[0]).toString(), 'err');
+
+		assert.strictEqual((<Placeholder>p2).index, 1);
+		assert.strictEqual((<Placeholder>p2).children.length, 1);
+		assert.strictEqual((<Text>(<Placeholder>p2).children[0]).toString(), 'err');
+	});
+
+	// TODO @jrieken making this strictEqul causes circular json conversion errors
+	test('Parser, default placeholder values and one transform', () => {
+
+		assertMarker('errorContext: `${1:err}`, error: ${1/err/ok/}', Text, Placeholder, Text, Placeholder);
+
+		const [, p3, , p4] = new SnippetParser().parse('errorContext: `${1:err}`, error:${1/err/ok/}').children;
+
+		assert.strictEqual((<Placeholder>p3).index, 1);
+		assert.strictEqual((<Placeholder>p3).children.length, 1);
+		assert.strictEqual((<Text>(<Placeholder>p3).children[0]).toString(), 'err');
+		assert.strictEqual((<Placeholder>p3).transform, undefined);
+
+		assert.strictEqual((<Placeholder>p4).index, 1);
+		assert.strictEqual((<Placeholder>p4).children.length, 1);
+		assert.strictEqual((<Text>(<Placeholder>p4).children[0]).toString(), 'err');
+		assert.notStrictEqual((<Placeholder>p4).transform, undefined);
+	});
+
+	test('Repeated snippet placeholder should always inherit, #31040', function () {
+		assertText('${1:foo}-abc-$1', 'foo-abc-foo');
+		assertText('${1:foo}-abc-${1}', 'foo-abc-foo');
+		assertText('${1:foo}-abc-${1:bar}', 'foo-abc-foo');
+		assertText('${1}-abc-${1:foo}', 'foo-abc-foo');
+	});
+
+	test('backspace esapce in TM only, #16212', () => {
+		const actual = new SnippetParser().text('Foo \\\\${abc}bar');
+		assert.strictEqual(actual, 'Foo \\bar');
+	});
+
+	test('colon as variable/placeholder value, #16717', () => {
+		let actual = new SnippetParser().text('${TM_SELECTED_TEXT:foo:bar}');
+		assert.strictEqual(actual, 'foo:bar');
+
+		actual = new SnippetParser().text('${1:foo:bar}');
+		assert.strictEqual(actual, 'foo:bar');
+	});
+
+	test('incomplete placeholder', () => {
+		assertTextAndMarker('${1:}', '', Placeholder);
+	});
+
+	test('marker#len', () => {
+
+		function assertLen(template: string, ...lengths: number[]): void {
+			const snippet = new SnippetParser().parse(template, true);
+			snippet.walk(m => {
+				const expected = lengths.shift();
+				assert.strictEqual(m.len(), expected);
+				return true;
+			});
+			assert.strictEqual(lengths.length, 0);
+		}
+
+		assertLen('text$0', 4, 0);
+		assertLen('$1text$0', 0, 4, 0);
+		assertLen('te$1xt$0', 2, 0, 2, 0);
+		assertLen('errorContext: `${1:err}`, error: $0', 15, 0, 3, 10, 0);
+		assertLen('errorContext: `${1:err}`, error: $1$0', 15, 0, 3, 10, 0, 3, 0);
+		assertLen('$TM_SELECTED_TEXT$0', 0, 0);
+		assertLen('${TM_SELECTED_TEXT:def}$0', 0, 3, 0);
+	});
+
+	test('parser, parent node', function () {
+		let snippet = new SnippetParser().parse('This ${1:is ${2:nested}}$0', true);
+
+		assert.strictEqual(snippet.placeholders.length, 3);
+		let [first, second] = snippet.placeholders;
+		assert.strictEqual(first.index, 1);
+		assert.strictEqual(second.index, 2);
+		assert.ok(second.parent === first);
+		assert.ok(first.parent === snippet);
+
+		snippet = new SnippetParser().parse('${VAR:default${1:value}}$0', true);
+		assert.strictEqual(snippet.placeholders.length, 2);
+		[first] = snippet.placeholders;
+		assert.strictEqual(first.index, 1);
+
+		assert.ok(snippet.children[0] instanceof Variable);
+		assert.ok(first.parent === snippet.children[0]);
+	});
+
+	test('TextmateSnippet#enclosingPlaceholders', () => {
+		let snippet = new SnippetParser().parse('This ${1:is ${2:nested}}$0', true);
+		let [first, second] = snippet.placeholders;
+
+		assert.deepStrictEqual(snippet.enclosingPlaceholders(first), []);
+		assert.deepStrictEqual(snippet.enclosingPlaceholders(second), [first]);
+	});
+
+	test('TextmateSnippet#offset', () => {
+		let snippet = new SnippetParser().parse('te$1xt', true);
+		assert.strictEqual(snippet.offset(snippet.children[0]), 0);
+		assert.strictEqual(snippet.offset(snippet.children[1]), 2);
+		assert.strictEqual(snippet.offset(snippet.children[2]), 2);
+
+		snippet = new SnippetParser().parse('${TM_SELECTED_TEXT:def}', true);
+		assert.strictEqual(snippet.offset(snippet.children[0]), 0);
+		assert.strictEqual(snippet.offset((<Variable>snippet.children[0]).children[0]), 0);
+
+		// forgein marker
+		assert.strictEqual(snippet.offset(new Text('foo')), -1);
+	});
+
+	test('TextmateSnippet#placeholder', () => {
+		let snippet = new SnippetParser().parse('te$1xt$0', true);
+		let placeholders = snippet.placeholders;
+		assert.strictEqual(placeholders.length, 2);
+
+		snippet = new SnippetParser().parse('te$1xt$1$0', true);
+		placeholders = snippet.placeholders;
+		assert.strictEqual(placeholders.length, 3);
+
+
+		snippet = new SnippetParser().parse('te$1xt$2$0', true);
+		placeholders = snippet.placeholders;
+		assert.strictEqual(placeholders.length, 3);
+
+		snippet = new SnippetParser().parse('${1:bar${2:foo}bar}$0', true);
+		placeholders = snippet.placeholders;
+		assert.strictEqual(placeholders.length, 3);
+	});
+
+	test('TextmateSnippet#replace 1/2', function () {
+		let snippet = new SnippetParser().parse('aaa${1:bbb${2:ccc}}$0', true);
+
+		assert.strictEqual(snippet.placeholders.length, 3);
+		const [, second] = snippet.placeholders;
+		assert.strictEqual(second.index, 2);
+
+		const enclosing = snippet.enclosingPlaceholders(second);
+		assert.strictEqual(enclosing.length, 1);
+		assert.strictEqual(enclosing[0].index, 1);
+
+		let nested = new SnippetParser().parse('ddd$1eee$0', true);
+		snippet.replace(second, nested.children);
+
+		assert.strictEqual(snippet.toString(), 'aaabbbdddeee');
+		assert.strictEqual(snippet.placeholders.length, 4);
+		assert.strictEqual(snippet.placeholders[0].index, 1);
+		assert.strictEqual(snippet.placeholders[1].index, 1);
+		assert.strictEqual(snippet.placeholders[2].index, 0);
+		assert.strictEqual(snippet.placeholders[3].index, 0);
+
+		const newEnclosing = snippet.enclosingPlaceholders(snippet.placeholders[1]);
+		assert.ok(newEnclosing[0] === snippet.placeholders[0]);
+		assert.strictEqual(newEnclosing.length, 1);
+		assert.strictEqual(newEnclosing[0].index, 1);
+	});
+
+	test('TextmateSnippet#replace 2/2', function () {
+		let snippet = new SnippetParser().parse('aaa${1:bbb${2:ccc}}$0', true);
+
+		assert.strictEqual(snippet.placeholders.length, 3);
+		const [, second] = snippet.placeholders;
+		assert.strictEqual(second.index, 2);
+
+		let nested = new SnippetParser().parse('dddeee$0', true);
+		snippet.replace(second, nested.children);
+
+		assert.strictEqual(snippet.toString(), 'aaabbbdddeee');
+		assert.strictEqual(snippet.placeholders.length, 3);
+	});
+
+	test('Snippet order for placeholders, #28185', function () {
+
+		const _10 = new Placeholder(10);
+		const _2 = new Placeholder(2);
+
+		assert.strictEqual(Placeholder.compareByIndex(_10, _2), 1);
+	});
+
+	test('Maximum call stack size exceeded, #28983', function () {
+		new SnippetParser().parse('${1:${foo:${1}}}');
+	});
+
+	test('Snippet can freeze the editor, #30407', function () {
+
+		const seen = new Set<Marker>();
+
+		seen.clear();
+		new SnippetParser().parse('class ${1:${TM_FILENAME/(?:\\A|_)([A-Za-z0-9]+)(?:\\.rb)?/(?2::\\u$1)/g}} < ${2:Application}Controller\n  $3\nend').walk(marker => {
+			assert.ok(!seen.has(marker));
+			seen.add(marker);
+			return true;
+		});
+
+		seen.clear();
+		new SnippetParser().parse('${1:${FOO:abc$1def}}').walk(marker => {
+			assert.ok(!seen.has(marker));
+			seen.add(marker);
+			return true;
+		});
+	});
+
+	test('Snippets: make parser ignore `${0|choice|}`, #31599', function () {
+		assertTextAndMarker('${0|foo,bar|}', '${0|foo,bar|}', Text);
+		assertTextAndMarker('${1|foo,bar|}', 'foo', Placeholder);
+	});
+
+
+	test('Transform -> FormatString#resolve', function () {
+
+		// shorthand functions
+		assert.strictEqual(new FormatString(1, 'upcase').resolve('foo'), 'FOO');
+		assert.strictEqual(new FormatString(1, 'downcase').resolve('FOO'), 'foo');
+		assert.strictEqual(new FormatString(1, 'capitalize').resolve('bar'), 'Bar');
+		assert.strictEqual(new FormatString(1, 'capitalize').resolve('bar no repeat'), 'Bar no repeat');
+		assert.strictEqual(new FormatString(1, 'pascalcase').resolve('bar-foo'), 'BarFoo');
+		assert.strictEqual(new FormatString(1, 'pascalcase').resolve('bar-42-foo'), 'Bar42Foo');
+		assert.strictEqual(new FormatString(1, 'camelcase').resolve('bar-foo'), 'barFoo');
+		assert.strictEqual(new FormatString(1, 'camelcase').resolve('bar-42-foo'), 'bar42Foo');
+		assert.strictEqual(new FormatString(1, 'notKnown').resolve('input'), 'input');
+
+		// if
+		assert.strictEqual(new FormatString(1, undefined, 'foo', undefined).resolve(undefined), '');
+		assert.strictEqual(new FormatString(1, undefined, 'foo', undefined).resolve(''), '');
+		assert.strictEqual(new FormatString(1, undefined, 'foo', undefined).resolve('bar'), 'foo');
+
+		// else
+		assert.strictEqual(new FormatString(1, undefined, undefined, 'foo').resolve(undefined), 'foo');
+		assert.strictEqual(new FormatString(1, undefined, undefined, 'foo').resolve(''), 'foo');
+		assert.strictEqual(new FormatString(1, undefined, undefined, 'foo').resolve('bar'), 'bar');
+
+		// if-else
+		assert.strictEqual(new FormatString(1, undefined, 'bar', 'foo').resolve(undefined), 'foo');
+		assert.strictEqual(new FormatString(1, undefined, 'bar', 'foo').resolve(''), 'foo');
+		assert.strictEqual(new FormatString(1, undefined, 'bar', 'foo').resolve('baz'), 'bar');
+	});
+
+	test('Snippet variable transformation doesn\'t work if regex is complicated and snippet body contains \'$$\' #55627', function () {
+		const snippet = new SnippetParser().parse('const fileName = "${TM_FILENAME/(.*)\\..+$/$1/}"');
+		assert.strictEqual(snippet.toTextmateString(), 'const fileName = "${TM_FILENAME/(.*)\\..+$/${1}/}"');
+	});
+
+	test('[BUG] HTML attribute suggestions: Snippet session does not have end-position set, #33147', function () {
+
+		const { placeholders } = new SnippetParser().parse('src="$1"', true);
+		const [first, second] = placeholders;
+
+		assert.strictEqual(placeholders.length, 2);
+		assert.strictEqual(first.index, 1);
+		assert.strictEqual(second.index, 0);
+
+	});
+
+	test('Snippet optional transforms are not applied correctly when reusing the same variable, #37702', function () {
+
+		const transform = new Transform();
+		transform.appendChild(new FormatString(1, 'upcase'));
+		transform.appendChild(new FormatString(2, 'upcase'));
+		transform.regexp = /^(.)|-(.)/g;
+
+		assert.strictEqual(transform.resolve('my-file-name'), 'MyFileName');
+
+		const clone = transform.clone();
+		assert.strictEqual(clone.resolve('my-file-name'), 'MyFileName');
+	});
+
+	test('problem with snippets regex #40570', function () {
+
+		const snippet = new SnippetParser().parse('${TM_DIRECTORY/.*src[\\/](.*)/$1/}');
+		assertMarker(snippet, Variable);
+	});
+
+	test('Variable transformation doesn\'t work if undefined variables are used in the same snippet #51769', function () {
+		let transform = new Transform();
+		transform.appendChild(new Text('bar'));
+		transform.regexp = new RegExp('foo', 'gi');
+		assert.strictEqual(transform.toTextmateString(), '/foo/bar/ig');
+	});
+
+	test('Snippet parser freeze #53144', function () {
+		let snippet = new SnippetParser().parse('${1/(void$)|(.+)/${1:?-\treturn nil;}/}');
+		assertMarker(snippet, Placeholder);
+	});
+
+	test('snippets variable not resolved in JSON proposal #52931', function () {
+		assertTextAndMarker('FOO${1:/bin/bash}', 'FOO/bin/bash', Text, Placeholder);
+	});
+
+	test('Mirroring sequence of nested placeholders not selected properly on backjumping #58736', function () {
+		let snippet = new SnippetParser().parse('${3:nest1 ${1:nest2 ${2:nest3}}} $3');
+		assert.strictEqual(snippet.children.length, 3);
+		assert.ok(snippet.children[0] instanceof Placeholder);
+		assert.ok(snippet.children[1] instanceof Text);
+		assert.ok(snippet.children[2] instanceof Placeholder);
+
+		function assertParent(marker: Marker) {
+			marker.children.forEach(assertParent);
+			if (!(marker instanceof Placeholder)) {
+				return;
+			}
+			let found = false;
+			let m: Marker = marker;
+			while (m && !found) {
+				if (m.parent === snippet) {
+					found = true;
+				}
+				m = m.parent;
+			}
+			assert.ok(found);
+		}
+		let [, , clone] = snippet.children;
+		assertParent(clone);
+	});
+
+	test('Backspace can\'t be escaped in snippet variable transforms #65412', function () {
+
+		let snippet = new SnippetParser().parse('namespace ${TM_DIRECTORY/[\\/]/\\\\/g};');
+		assertMarker(snippet, Text, Variable, Text);
+	});
+
+	test('Snippet cannot escape closing bracket inside conditional insertion variable replacement #78883', function () {
+
+		let snippet = new SnippetParser().parse('${TM_DIRECTORY/(.+)/${1:+import { hello \\} from world}/}');
+		let variable = <Variable>snippet.children[0];
+		assert.strictEqual(snippet.children.length, 1);
+		assert.ok(variable instanceof Variable);
+		assert.ok(variable.transform);
+		assert.strictEqual(variable.transform!.children.length, 1);
+		assert.ok(variable.transform!.children[0] instanceof FormatString);
+		assert.strictEqual((<FormatString>variable.transform!.children[0]).ifValue, 'import { hello } from world');
+		assert.strictEqual((<FormatString>variable.transform!.children[0]).elseValue, undefined);
+	});
+
+	test('Snippet escape backslashes inside conditional insertion variable replacement #80394', function () {
+
+		let snippet = new SnippetParser().parse('${CURRENT_YEAR/(.+)/${1:+\\\\}/}');
+		let variable = <Variable>snippet.children[0];
+		assert.strictEqual(snippet.children.length, 1);
+		assert.ok(variable instanceof Variable);
+		assert.ok(variable.transform);
+		assert.strictEqual(variable.transform!.children.length, 1);
+		assert.ok(variable.transform!.children[0] instanceof FormatString);
+		assert.strictEqual((<FormatString>variable.transform!.children[0]).ifValue, '\\');
+		assert.strictEqual((<FormatString>variable.transform!.children[0]).elseValue, undefined);
+	});
+});

packages/foam-vscode/src/core/janitor/apply-text-edit.ts

@@ -13,8 +13,8 @@ export const applyTextEdit = (text: string, textEdit: TextEdit): string => {
   const eol = detectNewline(text) || os.EOL;
   const lines = text.split(eol);
   const characters = text.split('');
-  let startOffset = getOffset(lines, textEdit.range.start, eol);
-  let endOffset = getOffset(lines, textEdit.range.end, eol);
+  const startOffset = getOffset(lines, textEdit.range.start, eol);
+  const endOffset = getOffset(lines, textEdit.range.end, eol);
   const deleteCount = endOffset - startOffset;
 
   const textToAppend = `${textEdit.newText}`;
@@ -34,5 +34,5 @@ const getOffset = (
     offset = offset + lines[i].length + eolLen;
     i++;
   }
-  return offset + Math.min(position.character, lines[i].length);
+  return offset + Math.min(position.character, lines[i]?.length ?? 0);
 };

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

@@ -1,19 +1,15 @@
-import GithubSlugger from 'github-slugger';
 import { Resource } from '../model/note';
 import { Range } from '../model/range';
 import {
   createMarkdownReferences,
   stringifyMarkdownLinkReferenceDefinition,
-} from '../markdown-provider';
+} from '../services/markdown-provider';
 import { getHeadingFromFileName } from '../utils';
 import { FoamWorkspace } from '../model/workspace';
-import { uriToSlug } from '../utils/slug';
 
 export const LINK_REFERENCE_DEFINITION_HEADER = `[//begin]: # "Autogenerated link references for markdown compatibility"`;
 export const LINK_REFERENCE_DEFINITION_FOOTER = `[//end]: # "Autogenerated link references"`;
 
-const slugger = new GithubSlugger();
-
 export interface TextEdit {
   range: Range;
   newText: string;
@@ -60,7 +56,7 @@ export const generateLinkReferences = (
     const first = note.definitions[0];
     const last = note.definitions[note.definitions.length - 1];
 
-    var nonGeneratedReferenceDefinitions = note.definitions;
+    let nonGeneratedReferenceDefinitions = note.definitions;
 
     // if we have more definitions then referenced pages AND the page refers to a page
     // we expect non-generated link definitions to be present
@@ -119,7 +115,7 @@ export const generateLinkReferences = (
       return null;
     }
 
-    var fullReferences = `${newReferences}`;
+    let fullReferences = `${newReferences}`;
     // If there are any non-generated definitions, add those to the output as well
     if (
       nonGeneratedReferenceDefinitions.length > 0 &&
@@ -168,7 +164,7 @@ export const generateHeading = (note: Resource): TextEdit | null => {
 
   return {
     newText: `${paddingStart}# ${getHeadingFromFileName(
-      uriToSlug(note.uri)
+      note.uri.getName()
     )}${paddingEnd}`,
     range: Range.createFromPosition(
       note.source.contentStart,
@@ -176,14 +172,3 @@ export const generateHeading = (note: Resource): TextEdit | null => {
     ),
   };
 };
-
-/**
- *
- * @param fileName
- * @returns null if file name is already in kebab case otherise returns
- * the kebab cased file name
- */
-export const getKebabCaseFileName = (fileName: string) => {
-  const kebabCasedFileName = slugger.slug(fileName);
-  return kebabCasedFileName === fileName ? null : kebabCasedFileName;
-};

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

@@ -1,520 +0,0 @@
-import {
-  createMarkdownParser,
-  createMarkdownReferences,
-  ParserPlugin,
-} from './markdown-provider';
-import { DirectLink, WikiLink } from './model/note';
-import { Logger } from './utils/log';
-import { uriToSlug } from './utils/slug';
-import { URI } from './model/uri';
-import { FoamGraph } from './model/graph';
-import { Range } from './model/range';
-import { createTestWorkspace } 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 = (path: string, content: string) =>
-  createMarkdownParser([]).parse(URI.file(path), content);
-
-describe('Markdown loader', () => {
-  it('Converts markdown to notes', () => {
-    const workspace = createTestWorkspace();
-    workspace.set(createNoteFromMarkdown('/page-a.md', pageA));
-    workspace.set(createNoteFromMarkdown('/page-b.md', pageB));
-    workspace.set(createNoteFromMarkdown('/page-c.md', pageC));
-    workspace.set(createNoteFromMarkdown('/page-d.md', pageD));
-    workspace.set(createNoteFromMarkdown('/page-e.md', pageE));
-
-    expect(
-      workspace
-        .list()
-        .map(n => n.uri)
-        .map(uriToSlug)
-        .sort()
-    ).toEqual(['page-a', 'page-b', 'page-c', 'page-d', 'page-e']);
-  });
-
-  it('Ingores external links', () => {
-    const note = createNoteFromMarkdown(
-      '/path/to/page-a.md',
-      `
-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(
-      '/path/to/page-a.md',
-      `
-this is a [link to intro](#introduction)
-`
-    );
-    expect(note.links.length).toEqual(0);
-  });
-
-  it('Parses internal links correctly', () => {
-    const note = createNoteFromMarkdown(
-      '/path/to/page-a.md',
-      '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(
-      '/path/to/page-a.md',
-      '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('/page-a.md', pageA);
-    const noteB = createNoteFromMarkdown('/page-b.md', pageB);
-    const noteC = createNoteFromMarkdown('/page-c.md', pageC);
-    const noteD = createNoteFromMarkdown('/Page D.md', pageD);
-    const noteE = createNoteFromMarkdown('/page e.md', pageE);
-
-    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(
-      '/path/to/page-a.md',
-      '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(
-      '/dir1/page-a.md',
-      `
-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(
-      '/dir1/page-a.md',
-      `
-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.md',
-      `
-# Page A
-this note has a title
-    `
-    );
-    expect(note.title).toBe('Page A');
-  });
-
-  it('should default to file name if heading does not exist', () => {
-    const note = createNoteFromMarkdown(
-      '/page-d.md',
-      `
-This file has no heading.
-      `
-    );
-
-    expect(note.title).toEqual('page-d');
-  });
-
-  it('should give precedence to frontmatter title over other headings', () => {
-    const note = createNoteFromMarkdown(
-      '/page-e.md',
-      `
----
-title: Note Title
-date: 20-12-12
----
-
-# Other Note Title
-      `
-    );
-
-    expect(note.title).toBe('Note Title');
-  });
-
-  it('should support numbers', () => {
-    const note1 = createNoteFromMarkdown('/157.md', `hello`);
-    expect(note1.title).toBe('157');
-
-    const note2 = createNoteFromMarkdown('/157.md', `# 158`);
-    expect(note2.title).toBe('158');
-
-    const note3 = createNoteFromMarkdown(
-      '/157.md',
-      `
----
-title: 159
----
-
-# 158
-`
-    );
-    expect(note3.title).toBe('159');
-  });
-
-  it('should not break on empty titles (see #276)', () => {
-    const note = createNoteFromMarkdown(
-      '/Hello Page.md',
-      `
-#
-
-this note has an empty title line
-    `
-    );
-    expect(note.title).toEqual('Hello Page');
-  });
-});
-
-describe('frontmatter', () => {
-  it('should parse yaml frontmatter', () => {
-    const note = createNoteFromMarkdown(
-      '/page-e.md',
-      `
----
-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(
-      '/page-f.md',
-      `
----
----
-
-# Empty Frontmatter
-`
-    );
-
-    expect(note.properties).toEqual({});
-  });
-
-  it('should not fail when there are issues with parsing frontmatter', () => {
-    const note = createNoteFromMarkdown(
-      '/page-f.md',
-      `
----
-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('/dir1/page-a.md', pageA);
-    workspace
-      .set(noteA)
-      .set(createNoteFromMarkdown('/dir1/page-b.md', pageB))
-      .set(createNoteFromMarkdown('/dir1/page-c.md', pageC));
-
-    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('/dir1/page-a.md', pageA);
-    workspace
-      .set(noteA)
-      .set(createNoteFromMarkdown('/dir1/page-b.md', pageB))
-      .set(createNoteFromMarkdown('/dir1/page-c.md', pageC));
-
-    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('/dir1/page-a.md', pageA);
-    workspace
-      .set(noteA)
-      .set(createNoteFromMarkdown('/dir2/page-b.md', pageB))
-      .set(createNoteFromMarkdown('/dir3/page-c.md', pageC));
-
-    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(
-      '/dir1/page-a.md',
-      `
-# 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(
-      '/dir1/page-a.md',
-      `
-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(
-      '/dir1/page-a.md',
-      `
-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(
-      '/dir1/page-a.md',
-      `
----
-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(
-      '/dir1/page-a.md',
-      `
----
-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(
-      '/dir1/page-a.md',
-      `
----
-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(
-      '/dir1/page-a.md',
-      `
-# 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));
-  });
-});
-
-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: boolean = false
+    keepMonitoring = false,
+    debounceFor = 0
   ): FoamGraph {
-    let graph = new FoamGraph(workspace);
-
-    workspace.list().forEach(resource => graph.resolveResource(resource));
+    const graph = new FoamGraph(workspace);
+    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
-    let 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: boolean = false
+    keepMonitoring = false,
+    debounceFor = 0
   ): FoamTags {
-    let 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

@@ -1,5 +1,4 @@
 import { Logger } from '../utils/log';
-import { uriToSlug } from '../utils/slug';
 import { URI } from './uri';
 
 Logger.setLevel('error');
@@ -72,17 +71,13 @@ describe('Foam URI', () => {
     expect(URI.file('/my/file.markdown').resolve('../hello')).toEqual(
       URI.file('/hello.markdown')
     );
-  });
-
-  it('can be slugified', () => {
-    expect(uriToSlug(URI.file('/this/is/a/path.md'))).toEqual('path');
-    expect(uriToSlug(URI.file('../a/relative/path.md'))).toEqual('path');
-    expect(uriToSlug(URI.file('another/relative/path.md'))).toEqual('path');
-    expect(uriToSlug(URI.file('no-directory.markdown'))).toEqual(
-      'no-directory'
-    );
-    expect(uriToSlug(URI.file('many.dots.name.markdown'))).toEqual(
-      'manydotsname'
-    );
+    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

@@ -58,7 +58,7 @@ export class URI {
   }
 
   static file(value: string): URI {
-    let [path, authority] = pathUtils.fromFsPath(value);
+    const [path, authority] = pathUtils.fromFsPath(value);
     return new URI({ scheme: 'file', authority, path });
   }
 
@@ -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';
   }
@@ -187,6 +194,7 @@ function encode(uri: URI, skipEncoding: boolean): string {
     : encodeURIComponentMinimal;
 
   let res = '';
+  // eslint-disable-next-line prefer-const
   let { scheme, authority, path, query, fragment } = uri;
   if (scheme) {
     res += scheme;

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 {
@@ -61,12 +65,13 @@ export class FoamWorkspace implements IDisposable {
   }
 
   public listByIdentifier(identifier: string): Resource[] {
-    let needle = normalize('/' + identifier);
-    let mdNeedle = getExtension(needle) !== '.md' ? needle + '.md' : undefined;
-    let resources = [];
-    for (const key of this.resources.keys()) {
+    const needle = normalize('/' + identifier);
+    const mdNeedle =
+      getExtension(needle) !== '.md' ? needle + '.md' : undefined;
+    const resources = [];
+    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));
@@ -77,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)
@@ -101,21 +114,21 @@ 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;
-    let [path, fragment] = (reference as string).split('#');
+    const [path, fragment] = (reference as string).split('#');
     if (FoamWorkspace.isIdentifier(path)) {
       resource = this.listByIdentifier(path)[0];
     } else {
       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;
         }
       }
     }
@@ -127,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/datastore.ts

@@ -2,11 +2,12 @@ import micromatch from 'micromatch';
 import fs from 'fs';
 import { URI } from '../model/uri';
 import { Logger } from '../utils/log';
-import glob from 'glob';
+import { glob } from 'glob';
 import { promisify } from 'util';
 import { isWindows } from '../common/platform';
 
 const findAllFiles = promisify(glob);
+
 export interface IMatcher {
   /**
    * Filters the given list of URIs, keepin only the ones that
@@ -117,6 +118,7 @@ export class FileDataStore implements IDataStore {
   async list(glob: string, ignoreGlob?: string | string[]): Promise<URI[]> {
     const res = await findAllFiles(glob, {
       ignore: ignoreGlob,
+      strict: false,
     });
     return res.map(URI.file);
   }

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

@@ -0,0 +1,238 @@
+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).toEqual('');
+      expect(parsed.alias).toEqual('');
+    });
+    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).toEqual('');
+    });
+    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).toEqual('');
+      expect(parsed.alias).toEqual('alias');
+    });
+    it('should parse links with square brackets #975', () => {
+      const link = parser.parse(
+        getRandomURI(),
+        `this is a [[wikilink [with] brackets]]`
+      ).links[0];
+      const parsed = MarkdownLink.analyzeLink(link);
+      expect(parsed.target).toEqual('wikilink [with] brackets');
+      expect(parsed.section).toEqual('');
+      expect(parsed.alias).toEqual('');
+    });
+    it('should parse links with square brackets in alias #975', () => {
+      const link = parser.parse(
+        getRandomURI(),
+        `this is a [[wikilink|alias [with] brackets]]`
+      ).links[0];
+      const parsed = MarkdownLink.analyzeLink(link);
+      expect(parsed.target).toEqual('wikilink');
+      expect(parsed.section).toEqual('');
+      expect(parsed.alias).toEqual('alias [with] brackets');
+    });
+    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).toEqual('');
+      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).toEqual('');
+      expect(parsed.section).toEqual('section');
+      expect(parsed.alias).toEqual('');
+    });
+  });
+
+  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).toEqual('');
+      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).toEqual('');
+      expect(parsed.section).toEqual('section');
+      expect(parsed.alias).toEqual('link');
+    });
+    it('should parse links with square brackets in label #975', () => {
+      const link = parser.parse(
+        getRandomURI(),
+        `this is a [inbox [xyz]](to/path.md)`
+      ).links[0];
+      const parsed = MarkdownLink.analyzeLink(link);
+      expect(parsed.target).toEqual('to/path.md');
+      expect(parsed.section).toEqual('');
+      expect(parsed.alias).toEqual('inbox [xyz]');
+    });
+    it('should parse links with empty label #975', () => {
+      const link = parser.parse(getRandomURI(), `this is a [](to/path.md)`)
+        .links[0];
+      const parsed = MarkdownLink.analyzeLink(link);
+      expect(parsed.target).toEqual('to/path.md');
+      expect(parsed.section).toEqual('');
+      expect(parsed.alias).toEqual('');
+    });
+  });
+
+  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,61 @@
+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: section ?? '',
+        alias: alias ?? '',
+      };
+    }
+    if (link.type === 'link') {
+      const [, alias, target, section] = this.directLinkRegex.exec(
+        link.rawText
+      );
+      return {
+        target: target ?? '',
+        section: section ?? '',
+        alias: 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

@@ -1,31 +1,19 @@
-import { Node, Position as AstPosition } from 'unist';
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { Point, Node, Position as AstPosition } from 'unist';
 import unified from 'unified';
 import markdownParse from 'remark-parse';
 import wikiLinkPlugin from 'remark-wiki-link';
 import frontmatterPlugin from 'remark-frontmatter';
 import { parse as parseYAML } from 'yaml';
 import visit from 'unist-util-visit';
-import { Parent, Point } from 'unist';
 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,136 +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));
+  for (const plugin of plugins) {
+    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());
+      for (const plugin of plugins) {
+        try {
+          plugin.onWillParseMarkdown?.(markdown);
+        } catch (e) {
+          handleError(plugin, 'onWillParseMarkdown', uri, e);
         }
-      })
-    );
-
-    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;
-  }
+      const tree = parser.parse(markdown);
+      const eol = detectNewline(markdown) || os.EOL;
 
-  async fetch(uri: URI) {
-    const content = await this.read(uri);
-    return isSome(content) ? this.parser.parse(uri, content) : null;
-  }
+      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,
+        },
+      };
 
-  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);
+      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
+            );
 
-          if (section) {
-            targetUri = targetUri.withFragment(section);
+            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);
+        for (const plugin of plugins) {
+          try {
+            plugin.visit?.(node, note, markdown);
+          } catch (e) {
+            handleError(plugin, 'visit', uri, e);
+          }
         }
-        break;
-    }
-    return targetUri;
-  }
-
-  dispose() {
-    this.disposables.forEach(d => d.dispose());
-  }
+      });
+      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;
 }
 
 /**
@@ -177,9 +145,9 @@ export class MarkdownResourceProvider implements ResourceProvider {
  */
 const getTextFromChildren = (root: Node): string => {
   let text = '';
-  visit(root, 'text', node => {
-    if (node.type === 'text') {
-      text = text + (node as any).value;
+  visit(root, node => {
+    if (node.type === 'text' || node.type === 'wikiLink') {
+      text = text + ((node as any).value || '');
     }
   });
   return text;
@@ -190,19 +158,19 @@ 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 => {
-        let start = astPointToFoamPosition(node.position!.start);
+      for (const tag of tags) {
+        const start = astPointToFoamPosition(node.position!.start);
         start.character = start.character + tag.offset;
         const end: Position = {
           line: start.line,
@@ -212,7 +180,7 @@ const tagsPlugin: ParserPlugin = {
           label: tag.label,
           range: Range.createFromPosition(start, end),
         });
-      });
+      }
     }
   },
 };
@@ -226,7 +194,7 @@ const sectionsPlugin: ParserPlugin = {
   visit: (node, note) => {
     if (node.type === 'heading') {
       const level = (node as any).depth;
-      const label = ((node as Parent)!.children?.[0] as any)?.value;
+      const label = getTextFromChildren(node);
       if (!label || !level) {
         return;
       }
@@ -272,8 +240,8 @@ const titlePlugin: ParserPlugin = {
       node.type === 'heading' &&
       (node as any).depth === 1
     ) {
-      note.title =
-        ((node as Parent)!.children?.[0] as any)?.value || note.title;
+      const title = getTextFromChildren(node);
+      note.title = title.length > 0 ? title : note.title;
     }
   },
   onDidFindProperties: (props, note) => {
@@ -291,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!),
       });
     }
@@ -321,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!),
       });
     }
@@ -364,123 +321,12 @@ 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;
-
-      var 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
 ): NoteLinkDefinition[] {
   let previousLine = fileEndPoint.line;
-  let foamDefinitions = [];
+  const foamDefinitions = [];
 
   // walk through each definition in reverse order
   // (last one first)
@@ -500,68 +346,6 @@ function getFoamDefinitions(
   return foamDefinitions;
 }
 
-export function stringifyMarkdownLinkReferenceDefinition(
-  definition: NoteLinkDefinition
-) {
-  let 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)
@@ -583,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,292 @@
+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);
+    });
+
+    it('should resolve wikilink with section identifier', () => {
+      const noteA = createTestNote({
+        uri: '/path/to/page-a.md',
+        links: [
+          // uppercased filename, lowercased slug
+          { slug: 'page-b#section' },
+        ],
+      });
+      const noteB = createTestNote({ uri: '/somewhere/PAGE-B.md' });
+      const ws = createTestWorkspace()
+        .set(noteA)
+        .set(noteB);
+
+      expect(ws.resolveLink(noteA, noteA.links[0])).toEqual(
+        noteB.uri.withFragment('section')
+      );
+    });
+
+    it('should resolve section-only wikilinks', () => {
+      const noteA = createTestNote({
+        uri: '/path/to/page-a.md',
+        links: [
+          // uppercased filename, lowercased slug
+          { slug: '#section' },
+        ],
+      });
+      const ws = createTestWorkspace().set(noteA);
+
+      expect(ws.resolveLink(noteA, noteA.links[0])).toEqual(
+        noteA.uri.withFragment('section')
+      );
+    });
+  });
+
+  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,221 @@
+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': {
+        // force ambiguous links to be treated as relative
+        const path =
+          target.startsWith('/') ||
+          target.startsWith('./') ||
+          target.startsWith('../')
+            ? target
+            : './' + target;
+        targetUri =
+          workspace.find(path, resource.uri)?.uri ??
+          URI.placeholder(resource.uri.resolve(path).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/core/utils/core.ts

@@ -1,19 +1,19 @@
 import crypto from 'crypto';
 
 export function isNotNull<T>(value: T | null): value is T {
-  return value != null; // eslint-disable-line
+  return value != null;
 }
 
 export function isSome<T>(
   value: T | null | undefined | void
 ): value is NonNullable<T> {
-  return value != null; // eslint-disable-line
+  return value != null;
 }
 
 export function isNone<T>(
   value: T | null | undefined | void
 ): value is null | undefined | void {
-  return value == null; // eslint-disable-line
+  return value == null;
 }
 
 export function isNumeric(value: string): boolean {

packages/foam-vscode/src/core/utils/log.ts

@@ -58,7 +58,9 @@ export class ConsoleLogger extends BaseLogger {
 }
 
 export class NoOpLogger extends BaseLogger {
-  log(_l: LogLevel, _m?: string, ..._p: any[]): void {}
+  log(_l: LogLevel, _m?: string, ..._p: any[]): void {
+    // do nothing
+  }
 }
 
 export class Logger {

packages/foam-vscode/src/core/utils/slug.ts

@@ -1,5 +0,0 @@
-import GithubSlugger from 'github-slugger';
-import { URI } from '../model/uri';
-
-export const uriToSlug = (uri: URI): string =>
-  GithubSlugger.slug(uri.getName());

packages/foam-vscode/src/dated-notes.spec.ts

@@ -81,7 +81,7 @@ describe('Daily note template', () => {
     const config = workspace.getConfiguration('foam');
     const uri = getDailyNotePath(config, targetDate);
 
-    await createDailyNoteIfNotExists(config, uri, targetDate);
+    await createDailyNoteIfNotExists(targetDate);
 
     const doc = await showInEditor(uri);
     const content = doc.editor.document.getText();

packages/foam-vscode/src/dated-notes.ts

@@ -1,9 +1,8 @@
 import { workspace, WorkspaceConfiguration } from 'vscode';
 import dateFormat from 'dateformat';
-import { existsInFs } from './core/utils/path';
 import { focusNote } from './utils';
 import { URI } from './core/model/uri';
-import { fromVsCodeUri } from './utils/vsc-utils';
+import { fromVsCodeUri, toVsCodeUri } from './utils/vsc-utils';
 import { NoteFactory } from './services/templates';
 
 /**
@@ -15,21 +14,14 @@ import { NoteFactory } from './services/templates';
  * @param date A given date to be formatted as filename.
  */
 export async function openDailyNoteFor(date?: Date) {
-  const foamConfiguration = workspace.getConfiguration('foam');
-  const currentDate = date !== undefined ? date : new Date();
+  const targetDate = date instanceof Date ? date : new Date();
 
-  const dailyNotePath = getDailyNotePath(foamConfiguration, currentDate);
-
-  const isNew = await createDailyNoteIfNotExists(
-    foamConfiguration,
-    dailyNotePath,
-    currentDate
-  );
+  const { didCreateFile, uri } = await createDailyNoteIfNotExists(targetDate);
   // if a new file is created, the editor is automatically created
   // but forcing the focus will block the template placeholders from working
   // so we only explicitly focus on the note if the file already exists
-  if (!isNew) {
-    await focusNote(dailyNotePath, isNew);
+  if (!didCreateFile) {
+    await focusNote(uri, didCreateFile);
   }
 }
 
@@ -96,37 +88,31 @@ export function getDailyNoteFileName(
  * In the case that the folders referenced in the file path also do not exist,
  * this function will create all folders in the path.
  *
- * @param configuration The current workspace configuration.
- * @param dailyNotePath The path to daily note file.
  * @param currentDate The current date, to be used as a title.
  * @returns Wether the file was created.
  */
-export async function createDailyNoteIfNotExists(
-  configuration: WorkspaceConfiguration,
-  dailyNotePath: URI,
-  targetDate: Date
-) {
-  if (await existsInFs(dailyNotePath.toFsPath())) {
-    return false;
-  }
-
+export async function createDailyNoteIfNotExists(targetDate: Date) {
+  const configuration = workspace.getConfiguration('foam');
+  const pathFromLegacyConfiguration = getDailyNotePath(
+    configuration,
+    targetDate
+  );
   const titleFormat: string =
     configuration.get('openDailyNote.titleFormat') ??
     configuration.get('openDailyNote.filenameFormat');
 
-  const templateFallbackText: string = `---
+  const templateFallbackText = `---
 foam_template:
-  name: New Daily Note
-  description: Foam's default daily note template
+  filepath: "${workspace.asRelativePath(
+    toVsCodeUri(pathFromLegacyConfiguration)
+  )}"
 ---
 # ${dateFormat(targetDate, titleFormat, false)}
 `;
 
-  await NoteFactory.createFromDailyNoteTemplate(
-    dailyNotePath,
+  return await NoteFactory.createFromDailyNoteTemplate(
+    pathFromLegacyConfiguration,
     templateFallbackText,
     targetDate
   );
-
-  return true;
 }

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

@@ -10,7 +10,7 @@ import { FoamWorkspace } from '../core/model/workspace';
 import { FoamGraph } from '../core/model/graph';
 import { Resource, ResourceLink } from '../core/model/note';
 import { Range } from '../core/model/range';
-import { fromVsCodeUri } from '../utils/vsc-utils';
+import { fromVsCodeUri, toVsCodeUri } from '../utils/vsc-utils';
 
 const feature: FoamFeature = {
   activate: async (
@@ -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);
@@ -72,7 +73,7 @@ export class BacklinksTreeDataProvider
             ).split('\n');
             if (link.range.start.line < lines.length) {
               const line = lines[link.range.start.line];
-              let start = Math.max(0, link.range.start.character - 15);
+              const start = Math.max(0, link.range.start.character - 15);
               const ellipsis = start === 0 ? '' : '...';
 
               item.label = `${link.range.start.line}: ${ellipsis}${line.substr(
@@ -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,11 +129,11 @@ 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',
-      arguments: [resource.uri, { selection: link.range }],
+      arguments: [toVsCodeUri(resource.uri), { selection: link.range }],
       title: 'Go to link',
     };
   }

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

@@ -1,21 +1,13 @@
-// import { env, window, Uri, Position, Selection, commands } from 'vscode';
-// import * as vscode from 'vscode';
+import { env, Position, Selection, commands } from 'vscode';
+import { createFile, showInEditor } from '../test/test-utils-vscode';
 
 describe('copyWithoutBrackets', () => {
-  it('should pass CI', () => {
-    expect(true).toBe(true);
+  it('should get the input from the active editor selection', async () => {
+    const { uri } = await createFile('This is my [[test-content]].');
+    const { editor } = await showInEditor(uri);
+    editor.selection = new Selection(new Position(0, 0), new Position(1, 0));
+    await commands.executeCommand('foam-vscode.copy-without-brackets');
+    const value = await env.clipboard.readText();
+    expect(value).toEqual('This is my Test Content.');
   });
-  // it('should get the input from the active editor selection', async () => {
-  //   const doc = await vscode.workspace.openTextDocument(
-  //     Uri.parse('untitled:/hello.md')
-  //   );
-  //   const editor = await window.showTextDocument(doc);
-  //   editor.edit(builder => {
-  //     builder.insert(new Position(0, 0), 'This is my [[test-content]].');
-  //   });
-  //   editor.selection = new Selection(new Position(0, 0), new Position(1, 0));
-  //   await commands.executeCommand('foam-vscode.copy-without-brackets');
-  //   const value = await env.clipboard.readText();
-  //   expect(value).toEqual('This is my Test Content.');
-  // });
 });

packages/foam-vscode/src/features/create-from-template.spec.ts

@@ -1,7 +1,6 @@
-import { Uri } from 'vscode';
+import { Uri, commands, window, workspace } from 'vscode';
 import { URI } from '../core/model/uri';
 import { toVsCodeUri } from '../utils/vsc-utils';
-import { commands, window, workspace } from 'vscode';
 import { createFile } from '../test/test-utils-vscode';
 import * as editor from '../services/editor';
 

packages/foam-vscode/src/features/create-from-template.ts

@@ -117,7 +117,7 @@ const feature: FoamFeature = {
         () => {
           const resolver = new Resolver(new Map(), new Date());
 
-          NoteFactory.createFromTemplate(
+          return NoteFactory.createFromTemplate(
             DEFAULT_TEMPLATE_URI,
             resolver,
             undefined,

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;
         });
 
@@ -131,7 +127,7 @@ async function createGraphPanel(foam: Foam, context: vscode.ExtensionContext) {
   panel.webview.onDidReceiveMessage(
     async message => {
       switch (message.type) {
-        case 'webviewDidLoad':
+        case 'webviewDidLoad': {
           const styles = getGraphStyle();
           panel.webview.postMessage({
             type: 'didUpdateStyle',
@@ -139,8 +135,8 @@ async function createGraphPanel(foam: Foam, context: vscode.ExtensionContext) {
           });
           updateGraph(panel, foam);
           break;
-
-        case 'webviewDidSelectNode':
+        }
+        case 'webviewDidSelectNode': {
           const noteUri = vscode.Uri.parse(message.payload);
           const selectedNote = foam.workspace.get(fromVsCodeUri(noteUri));
 
@@ -151,10 +147,11 @@ async function createGraphPanel(foam: Foam, context: vscode.ExtensionContext) {
             vscode.window.showTextDocument(doc, vscode.ViewColumn.One);
           }
           break;
-
-        case 'error':
+        }
+        case 'error': {
           Logger.error('An error occurred in the graph view', message.payload);
           break;
+        }
       }
     },
     undefined,

packages/foam-vscode/src/features/document-decorator.ts

@@ -8,21 +8,15 @@ import {
 import { ResourceParser } from '../core/model/note';
 import { FoamWorkspace } from '../core/model/workspace';
 import { Foam } from '../core/model/foam';
+import { Range } from '../core/model/range';
 import { fromVsCodeUri } from '../utils/vsc-utils';
 
 export const CONFIG_KEY = 'decorations.links.enable';
 
-const linkDecoration = vscode.window.createTextEditorDecorationType({
-  rangeBehavior: vscode.DecorationRangeBehavior.ClosedClosed,
-  textDecoration: 'none',
-  color: { id: 'textLink.foreground' },
-  cursor: 'pointer',
-});
-
 const placeholderDecoration = vscode.window.createTextEditorDecorationType({
   rangeBehavior: vscode.DecorationRangeBehavior.ClosedClosed,
   textDecoration: 'none',
-  color: { id: 'editorWarning.foreground' },
+  color: { id: 'foam.placeholder' },
   cursor: 'pointer',
 });
 
@@ -42,17 +36,20 @@ const updateDecorations = (
     fromVsCodeUri(editor.document.uri),
     editor.document.getText()
   );
-  let linkRanges = [];
-  let placeholderRanges = [];
+  const placeholderRanges = [];
   note.links.forEach(link => {
     const linkUri = workspace.resolveLink(note, link);
     if (linkUri.isPlaceholder()) {
-      placeholderRanges.push(link.range);
-    } else {
-      linkRanges.push(link.range);
+      placeholderRanges.push(
+        Range.create(
+          link.range.start.line,
+          link.range.start.character + 2,
+          link.range.end.line,
+          link.range.end.character - 2
+        )
+      );
     }
   });
-  editor.setDecorations(linkDecoration, linkRanges);
   editor.setDecorations(placeholderDecoration, placeholderRanges);
 };
 
@@ -82,7 +79,6 @@ const feature: FoamFeature = {
 
     context.subscriptions.push(
       areDecorationsEnabled,
-      linkDecoration,
       placeholderDecoration,
       vscode.window.onDidChangeActiveTextEditor(editor => {
         activeEditor = editor;

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/janitor.ts

@@ -97,12 +97,12 @@ async function runJanitor(foam: Foam) {
   // Apply Text Edits to Non Dirty Notes using fs module just like CLI
 
   const fileWritePromises = nonDirtyNotes.map(note => {
-    let heading = generateHeading(note);
+    const heading = generateHeading(note);
     if (heading) {
       updatedHeadingCount += 1;
     }
 
-    let definitions =
+    const definitions =
       wikilinkSetting === LinkReferenceDefinitionsSetting.off
         ? null
         : generateLinkReferences(
@@ -140,7 +140,7 @@ async function runJanitor(foam: Foam) {
 
     // Get edits
     const heading = generateHeading(note);
-    let definitions =
+    const definitions =
       wikilinkSetting === LinkReferenceDefinitionsSetting.off
         ? null
         : generateLinkReferences(

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,
@@ -88,40 +87,48 @@ describe('Link Completion', () => {
   });
 
   it('should return notes with unique identifiers, and placeholders', async () => {
-    const { uri } = await createFile('[[file]] [[');
-    const { doc } = await showInEditor(uri);
-    const provider = new CompletionProvider(ws, graph);
+    for (const text of ['[[', '[[file]] [[', '[[file]] #tag [[']) {
+      const { uri } = await createFile(text);
+      const { doc } = await showInEditor(uri);
+      const provider = new CompletionProvider(ws, graph);
 
-    const links = await provider.provideCompletionItems(
-      doc,
-      new vscode.Position(0, 11)
-    );
+      const links = await provider.provideCompletionItems(
+        doc,
+        new vscode.Position(0, text.length)
+      );
 
-    expect(links.items.length).toEqual(5);
-    expect(new Set(links.items.map(i => i.insertText))).toEqual(
-      new Set([
-        'to/file',
-        'another/file',
-        'File name with spaces',
-        'file-name',
-        'placeholder text',
-      ])
-    );
+      expect(links.items.length).toEqual(5);
+      expect(new Set(links.items.map(i => i.insertText))).toEqual(
+        new Set([
+          'to/file',
+          'another/file',
+          'File name with spaces',
+          'file-name',
+          'placeholder text',
+        ])
+      );
+    }
   });
 
   it('should return sections for other notes', async () => {
-    const { uri } = await createFile('[[file-name#');
-    const { doc } = await showInEditor(uri);
-    const provider = new SectionCompletionProvider(ws);
+    for (const text of [
+      '[[file-name#',
+      '[[file]] [[file-name#',
+      '[[file]] #tag [[file-name#',
+    ]) {
+      const { uri } = await createFile(text);
+      const { doc } = await showInEditor(uri);
+      const provider = new SectionCompletionProvider(ws);
 
-    const links = await provider.provideCompletionItems(
-      doc,
-      new vscode.Position(0, 12)
-    );
+      const links = await provider.provideCompletionItems(
+        doc,
+        new vscode.Position(0, text.length)
+      );
 
-    expect(new Set(links.items.map(i => i.label))).toEqual(
-      new Set(['Section One', 'Section Two'])
-    );
+      expect(new Set(links.items.map(i => i.label))).toEqual(
+        new Set(['Section One', 'Section Two'])
+      );
+    }
   });
 
   it('should return sections within the note', async () => {

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

@@ -45,7 +45,6 @@ export class SectionCompletionProvider
 
     // Requires autocomplete only if cursorPrefix matches `[[` that NOT ended by `]]`.
     // See https://github.com/foambubble/foam/pull/596#issuecomment-825748205 for details.
-    // eslint-disable-next-line no-useless-escape
     const match = cursorPrefix.match(SECTION_REGEX);
 
     if (!match) {
@@ -104,10 +103,9 @@ export class CompletionProvider
 
     // Requires autocomplete only if cursorPrefix matches `[[` that NOT ended by `]]`.
     // See https://github.com/foambubble/foam/pull/596#issuecomment-825748205 for details.
-    // eslint-disable-next-line no-useless-escape
     const requiresAutocomplete = cursorPrefix.match(WIKILINK_REGEX);
 
-    if (!requiresAutocomplete || cursorPrefix.indexOf('#') >= 0) {
+    if (!requiresAutocomplete || requiresAutocomplete[0].indexOf('#') >= 0) {
       return null;
     }
 

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));
@@ -69,12 +68,12 @@ describe('Document navigation', () => {
 
       expect(links.length).toEqual(1);
       expect(links[0].target).toEqual(OPEN_COMMAND.asURI(fileA.uri));
-      expect(links[0].range).toEqual(new vscode.Range(0, 18, 0, 28));
+      expect(links[0].range).toEqual(new vscode.Range(0, 20, 0, 26));
     });
 
     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);
@@ -87,7 +86,7 @@ describe('Document navigation', () => {
       expect(links[0].target).toEqual(
         OPEN_COMMAND.asURI(URI.placeholder('a placeholder'))
       );
-      expect(links[0].range).toEqual(new vscode.Range(0, 18, 0, 35));
+      expect(links[0].range).toEqual(new vscode.Range(0, 20, 0, 33));
     });
   });
 
@@ -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];
   }
@@ -156,7 +157,12 @@ export class NavigationProvider
     return targets.map(o => {
       const command = OPEN_COMMAND.asURI(o.target);
       const documentLink = new vscode.DocumentLink(
-        toVsCodeRange(o.link.range),
+        new vscode.Range(
+          o.link.range.start.line,
+          o.link.range.start.character + 2,
+          o.link.range.end.line,
+          o.link.range.end.character - 2
+        ),
         command
       );
       documentLink.tooltip = o.target.isPlaceholder()

packages/foam-vscode/src/features/open-daily-note.ts

@@ -1,15 +1,15 @@
-import { ExtensionContext, commands, workspace } from 'vscode';
+import { ExtensionContext, commands } from 'vscode';
 import { FoamFeature } from '../types';
 import { openDailyNoteFor } from '../dated-notes';
+import { getFoamVsCodeConfig } from '../services/config';
 
 const feature: FoamFeature = {
   activate: (context: ExtensionContext) => {
     context.subscriptions.push(
       commands.registerCommand('foam-vscode.open-daily-note', openDailyNoteFor)
     );
-    if (
-      workspace.getConfiguration('foam').get('openDailyNote.onStartup', false)
-    ) {
+
+    if (getFoamVsCodeConfig('openDailyNote.onStartup', false)) {
       commands.executeCommand('foam-vscode.open-daily-note');
     }
   },

packages/foam-vscode/src/features/open-dated-note.ts

@@ -13,7 +13,6 @@ import {
   createDailyNoteIfNotExists,
   getDailyNoteFileName,
   openDailyNoteFor,
-  getDailyNotePath,
 } from '../dated-notes';
 import { FoamFeature } from '../types';
 
@@ -215,11 +214,7 @@ const datedNoteCommand = (date: Date) => {
     return openDailyNoteFor(date);
   }
   if (foamNavigateOnSelect === 'createNote') {
-    return createDailyNoteIfNotExists(
-      foamConfig,
-      getDailyNotePath(foamConfig, date),
-      date
-    );
+    return createDailyNoteIfNotExists(date);
   }
 };
 

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 {
@@ -11,6 +11,7 @@ import {
   markdownItWithFoamLinks,
   markdownItWithFoamTags,
   markdownItWithNoteInclusion,
+  markdownItWithRemoveLinkReferences,
 } from './preview-navigation';
 
 describe('Link generation in preview', () => {
@@ -22,7 +23,11 @@ describe('Link generation in preview', () => {
     links: [{ slug: 'placeholder' }],
   });
   const ws = new FoamWorkspace().set(noteA);
-  const md = markdownItWithFoamLinks(MarkdownIt(), ws);
+
+  const md = [
+    markdownItWithFoamLinks,
+    markdownItWithRemoveLinkReferences,
+  ].reduce((acc, extension) => extension(acc, ws), MarkdownIt());
 
   it('generates a link to a note', () => {
     expect(md.render(`[[note-a]]`)).toEqual(
@@ -41,6 +46,14 @@ describe('Link generation in preview', () => {
       `<p><a class='foam-placeholder-link' title="Link to non-existing resource" href="javascript:void(0);">random-text</a></p>\n`
     );
   });
+
+  it('generates a wikilink even when there is a link reference', () => {
+    const note = `[[note-a]]
+    [note-a]: <note-a.md> "Note A"`;
+    expect(md.render(note)).toEqual(
+      `<p><a class='foam-note-link' title='${noteA.title}' href='/path/to/note-a.md' data-href='/path/to/note-a.md'>note-a</a>\n[note-a]: &lt;note-a.md&gt; &quot;Note A&quot;</p>\n`
+    );
+  });
 });
 
 describe('Stylable tag generation in preview', () => {

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

@@ -155,18 +155,17 @@ export const markdownItWithRemoveLinkReferences = (
 ) => {
   md.inline.ruler.before('link', 'clear-references', state => {
     if (state.env.references) {
-      Object.keys(state.env.references).forEach(refKey => {
-        // Forget about reference links that contain an alias divider
-        // Aliased reference links will lead the MarkdownParser to include wrong link references
-        if (refKey.includes(ALIAS_DIVIDER_CHAR)) {
-          delete state.env.references[refKey];
-        }
+      const src = state.src.toLowerCase();
+      const foamLinkRegEx = /\[\[([^[\]]+?)\]\]/g;
+      const foamLinks = [...src.matchAll(foamLinkRegEx)].map(m =>
+        m[1].toLowerCase()
+      );
 
-        // When the reference is present due to an inclusion of that note, we
-        // need to remove that reference. This ensures the MarkdownIt parser
-        // will not replace the wikilink syntax with an <a href> link and as a result
-        // break our inclusion logic.
-        if (state.src.toLowerCase().includes(`![[${refKey.toLowerCase()}]]`)) {
+      Object.keys(state.env.references).forEach(refKey => {
+        // Remove all references that have corresponding wikilinks.
+        // If the markdown parser sees a reference, it will format it before
+        // we get a chance to create the wikilink.
+        if (foamLinks.includes(refKey.toLowerCase())) {
           delete state.env.references[refKey];
         }
       });

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', () => {
@@ -62,6 +62,7 @@ describe('Tags tree panel', () => {
 
     childTreeItems.forEach(child => {
       if (child instanceof TagItem) {
+        // eslint-disable-next-line jest/no-conditional-expect
         expect(child.title).toEqual('child');
       }
     });
@@ -94,7 +95,9 @@ describe('Tags tree panel', () => {
 
     childTreeItems.forEach(child => {
       if (child instanceof TagItem) {
+        // eslint-disable-next-line jest/no-conditional-expect
         expect(['child', 'subchild']).toContain(child.title);
+        // eslint-disable-next-line jest/no-conditional-expect
         expect(child.title).not.toEqual('parent');
       }
     });

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());
   },
 };
 
@@ -166,16 +164,14 @@ export class TagReference extends vscode.TreeItem {
   public readonly title: string;
   constructor(public readonly tag: Tag, public readonly note: Resource) {
     super(note.title, vscode.TreeItemCollapsibleState.None);
+    const uri = toVsCodeUri(note.uri);
     this.title = note.title;
-    this.description = note.uri.path.replace(
-      vscode.workspace.getWorkspaceFolder(toVsCodeUri(note.uri))?.uri.path,
-      ''
-    );
+    this.description = vscode.workspace.asRelativePath(uri);
     this.tooltip = undefined;
     this.command = {
       command: 'vscode.open',
       arguments: [
-        note.uri,
+        uri,
         {
           preview: true,
           selection: toVsCodeRange(tag.range),

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',
@@ -24,25 +23,27 @@ const feature: FoamFeature = {
         async (params: { uri: URI }) => {
           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);
-                }
-              }
+            case 'file': {
               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':
+            }
+            case 'placeholder': {
+              const title = uri.getName();
+              if (uri.isAbsolute()) {
+                return NoteFactory.createForPlaceholderWikilink(
+                  title,
+                  URI.file(uri.path)
+                );
+              }
               const basedir =
                 vscode.workspace.workspaceFolders.length > 0
                   ? vscode.workspace.workspaceFolders[0].uri
@@ -52,12 +53,12 @@ const feature: FoamFeature = {
               if (basedir === undefined) {
                 return;
               }
-              const title = uri.getName();
               const target = fromVsCodeUri(basedir)
                 .resolve(uri, true)
                 .changeExtension('', '.md');
               await NoteFactory.createForPlaceholderWikilink(title, target);
               return;
+            }
           }
         }
       )

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,35 +58,17 @@ 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(_ => {
-      let 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) {
-  let editor = window.activeTextEditor;
+  const editor = window.activeTextEditor;
 
   if (!editor || !isMdEditor(editor)) {
     return;
   }
 
-  let refs = await generateReferenceList(foam, editor.document);
+  const refs = await generateReferenceList(foam, editor.document);
   if (refs && refs.length) {
     await editor.edit(function(editBuilder) {
       if (editor) {
@@ -213,7 +196,7 @@ class WikilinkReferenceCodeLensProvider implements CodeLensProvider {
   ): CodeLens[] | Thenable<CodeLens[]> {
     loadDocConfig();
 
-    let range = detectReferenceListRange(document);
+    const range = detectReferenceListRange(document);
     if (!range) {
       return [];
     }
@@ -222,7 +205,7 @@ class WikilinkReferenceCodeLensProvider implements CodeLensProvider {
     const oldRefs = getText(range).replace(/\r?\n|\r/g, docConfig.eol);
     const newRefs = refs.join(docConfig.eol);
 
-    let status = oldRefs === newRefs ? 'up to date' : 'out of date';
+    const status = oldRefs === newRefs ? 'up to date' : 'out of date';
 
     return [
       new CodeLens(range, {

packages/foam-vscode/src/services/config.ts

@@ -4,8 +4,8 @@ export interface ConfigurationMonitor<T> extends Disposable {
   (): T;
 }
 
-export const getFoamVsCodeConfig = <T>(key: string): T =>
-  workspace.getConfiguration('foam').get(key);
+export const getFoamVsCodeConfig = <T>(key: string, defaultValue?: T): T =>
+  workspace.getConfiguration('foam').get(key, defaultValue);
 
 export const updateFoamVsCodeConfig = <T>(key: string, value: T) =>
   workspace.getConfiguration().update('foam.' + key, value);

packages/foam-vscode/src/services/editor.ts

@@ -48,8 +48,9 @@ export async function createDocAndFocus(
     toVsCodeUri(filepath),
     new TextEncoder().encode('')
   );
-  await focusNote(filepath, true, viewColumn);
-  await window.activeTextEditor.insertSnippet(text);
+  const note = await focusNote(filepath, true, viewColumn);
+  await note.editor.insertSnippet(text);
+  await note.document.save();
 }
 
 export async function replaceSelection(

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']
@@ -125,7 +125,7 @@ foam_template: # foam template metadata
       const target = getUriInWorkspace();
       const resolver = new Resolver(new Map(), new Date());
       await NoteFactory.createFromTemplate(templateA.uri, resolver, target);
-      expect(await resolver.resolve('FOAM_SELECTED_TEXT')).toEqual(
+      expect(await resolver.resolveFromName('FOAM_SELECTED_TEXT')).toEqual(
         'first file'
       );
 

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

@@ -13,6 +13,7 @@ import {
   replaceSelection,
 } from './editor';
 import { Resolver } from './variable-resolver';
+import dateFormat from 'dateformat';
 
 /**
  * The templates directory
@@ -69,12 +70,37 @@ export async function getTemplates(): Promise<URI[]> {
   return templates;
 }
 
+export async function getTemplateInfo(
+  templateUri: URI,
+  templateFallbackText = '',
+  resolver: Resolver
+) {
+  const templateText = existsSync(templateUri.toFsPath())
+    ? await workspace.fs
+        .readFile(toVsCodeUri(templateUri))
+        .then(bytes => bytes.toString())
+    : templateFallbackText;
+
+  const templateWithResolvedVariables = await resolver.resolveText(
+    templateText
+  );
+
+  const [
+    templateMetadata,
+    templateWithFoamFrontmatterRemoved,
+  ] = extractFoamTemplateFrontmatterMetadata(templateWithResolvedVariables);
+
+  return {
+    metadata: templateMetadata,
+    text: templateWithFoamFrontmatterRemoved,
+  };
+}
+
 export const NoteFactory = {
   /**
    * Creates a new note using a template.
-   * @param givenValues already resolved values of Foam template variables. These are used instead of resolving the Foam template variables.
-   * @param extraVariablesToResolve Foam template variables to resolve, in addition to those mentioned in the template.
    * @param templateUri the URI of the template to use.
+   * @param resolver the Resolver to use.
    * @param filepathFallbackURI the URI to use if the template does not specify the `filepath` metadata attribute. This is configurable by the caller for backwards compatibility purposes.
    * @param templateFallbackText the template text to use if the template does not exist. This is configurable by the caller for backwards compatibility purposes.
    */
@@ -82,71 +108,67 @@ export const NoteFactory = {
     templateUri: URI,
     resolver: Resolver,
     filepathFallbackURI?: URI,
-    templateFallbackText: string = ''
-  ): Promise<void> => {
-    const templateText = existsSync(templateUri.toFsPath())
-      ? await workspace.fs
-          .readFile(toVsCodeUri(templateUri))
-          .then(bytes => bytes.toString())
-      : templateFallbackText;
-
-    const selectedContent = findSelectionContent();
-
-    resolver.define('FOAM_SELECTED_TEXT', selectedContent?.content ?? '');
-    let templateWithResolvedVariables: string;
+    templateFallbackText = '',
+    onFileExists?: (filePath: URI) => Promise<string | undefined>
+  ): Promise<{ didCreateFile: boolean; uri: URI | undefined }> => {
     try {
-      [, templateWithResolvedVariables] = await resolver.resolveText(
-        templateText
+      onFileExists = onFileExists
+        ? onFileExists
+        : (existingFile: URI) => {
+            const filename = existingFile.getBasename();
+            return askUserForFilepathConfirmation(existingFile, filename);
+          };
+
+      const template = await getTemplateInfo(
+        templateUri,
+        templateFallbackText,
+        resolver
       );
+
+      const selectedContent = findSelectionContent();
+      if (selectedContent?.content) {
+        resolver.define('FOAM_SELECTED_TEXT', selectedContent?.content);
+      }
+
+      const templateSnippet = new SnippetString(template.text);
+
+      let newFilePath = await determineNewNoteFilepath(
+        template.metadata.get('filepath'),
+        filepathFallbackURI,
+        resolver
+      );
+      while (existsSync(newFilePath.toFsPath())) {
+        const proposedNewFilepath = await onFileExists(newFilePath);
+
+        if (proposedNewFilepath === undefined) {
+          return { didCreateFile: false, uri: newFilePath };
+        }
+        newFilePath = URI.file(proposedNewFilepath);
+      }
+
+      await createDocAndFocus(
+        templateSnippet,
+        newFilePath,
+        selectedContent ? ViewColumn.Beside : ViewColumn.Active
+      );
+
+      if (selectedContent !== undefined) {
+        const newNoteTitle = newFilePath.getName();
+
+        await replaceSelection(
+          selectedContent.document,
+          selectedContent.selection,
+          `[[${newNoteTitle}]]`
+        );
+      }
+
+      return { didCreateFile: true, uri: newFilePath };
     } catch (err) {
       if (err instanceof UserCancelledOperation) {
         return;
       }
       throw err;
     }
-
-    const [
-      templateMetadata,
-      templateWithFoamFrontmatterRemoved,
-    ] = extractFoamTemplateFrontmatterMetadata(templateWithResolvedVariables);
-    const templateSnippet = new SnippetString(
-      templateWithFoamFrontmatterRemoved
-    );
-
-    let filepath = await determineNewNoteFilepath(
-      templateMetadata.get('filepath'),
-      filepathFallbackURI,
-      resolver
-    );
-
-    if (existsSync(filepath.toFsPath())) {
-      const filename = filepath.getBasename();
-      const newFilepath = await askUserForFilepathConfirmation(
-        filepath,
-        filename
-      );
-
-      if (newFilepath === undefined) {
-        return;
-      }
-      filepath = URI.file(newFilepath);
-    }
-
-    await createDocAndFocus(
-      templateSnippet,
-      filepath,
-      selectedContent ? ViewColumn.Beside : ViewColumn.Active
-    );
-
-    if (selectedContent !== undefined) {
-      const newNoteTitle = filepath.getName();
-
-      await replaceSelection(
-        selectedContent.document,
-        selectedContent.selection,
-        `[[${newNoteTitle}]]`
-      );
-    }
   },
 
   /**
@@ -158,17 +180,17 @@ export const NoteFactory = {
     filepathFallbackURI: URI,
     templateFallbackText: string,
     targetDate: Date
-  ): Promise<void> => {
+  ): Promise<{ didCreateFile: boolean; uri: URI | undefined }> => {
     const resolver = new Resolver(
-      new Map(),
-      targetDate,
-      new Set(['FOAM_SELECTED_TEXT'])
+      new Map().set('FOAM_TITLE', dateFormat(targetDate, 'yyyy-mm-dd', false)),
+      targetDate
     );
     return NoteFactory.createFromTemplate(
       DAILY_NOTE_TEMPLATE_URI,
       resolver,
       filepathFallbackURI,
-      templateFallbackText
+      templateFallbackText,
+      _ => Promise.resolve(undefined)
     );
   },
 
@@ -180,11 +202,10 @@ export const NoteFactory = {
   createForPlaceholderWikilink: (
     wikilinkPlaceholder: string,
     filepathFallbackURI: URI
-  ): Promise<void> => {
+  ): Promise<{ didCreateFile: boolean; uri: URI | undefined }> => {
     const resolver = new Resolver(
       new Map().set('FOAM_TITLE', wikilinkPlaceholder),
-      new Date(),
-      new Set(['FOAM_TITLE', 'FOAM_SELECTED_TEXT'])
+      new Date()
     );
     return NoteFactory.createFromTemplate(
       DEFAULT_TEMPLATE_URI,
@@ -259,7 +280,7 @@ export async function determineNewNoteFilepath(
     return fallbackURI;
   }
 
-  const defaultName = await resolver.resolve('FOAM_TITLE');
+  const defaultName = await resolver.resolveFromName('FOAM_TITLE');
   const defaultFilepath = getCurrentEditorDirectory().joinPath(
     `${defaultName}.md`
   );

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

@@ -1,20 +1,34 @@
 import { window } from 'vscode';
 import { Resolver } from './variable-resolver';
+import { Variable } from '../core/common/snippetParser';
 
 describe('substituteFoamVariables', () => {
   test('Does nothing if no Foam-specific variables are used', async () => {
     const input = `
-      # \${AnotherVariable} <-- Unrelated to foam
-      # \${AnotherVariable:default_value} <-- Unrelated to foam
-      # \${AnotherVariable:default_value/(.*)/\${1:/upcase}/}} <-- Unrelated to foam
-      # $AnotherVariable} <-- Unrelated to foam
-      # $CURRENT_YEAR-\${CURRENT_MONTH}-$CURRENT_DAY <-- Unrelated to foam
+      # \${AnotherVariable} <-- Unrelated to Foam
+      # \${AnotherVariable:default_value} <-- Unrelated to Foam
+      # \${AnotherVariable:default_value/(.*)/\${1:/upcase}/}} <-- Unrelated to Foam
+      # $AnotherVariable} <-- Unrelated to Foam
+      # $CURRENT_YEAR-\${CURRENT_MONTH}-$CURRENT_DAY <-- Unrelated to Foam
     `;
 
     const givenValues = new Map<string, string>();
     givenValues.set('FOAM_TITLE', 'My note title');
     const resolver = new Resolver(givenValues, new Date());
-    expect((await resolver.resolveText(input))[1]).toEqual(input);
+    expect(await resolver.resolveText(input)).toEqual(input);
+  });
+
+  test('Ignores variable-looking text values', async () => {
+    // Related to https://github.com/foambubble/foam/issues/602
+    const input = `
+        # \${CURRENT_DATE/.*/\${FOAM_TITLE}/} <-- FOAM_TITLE is not a variable here, but a text in a transform
+        # \${1|one,two,\${FOAM_TITLE}|} <-- FOAM_TITLE is not a variable here, but a text in a choice
+      `;
+
+    const givenValues = new Map<string, string>();
+    givenValues.set('FOAM_TITLE', 'My note title');
+    const resolver = new Resolver(givenValues, new Date());
+    expect(await resolver.resolveText(input)).toEqual(input);
   });
 
   test('Correctly substitutes variables that are substrings of one another', async () => {
@@ -22,32 +36,31 @@ describe('substituteFoamVariables', () => {
     // If we're not careful with how we substitute the values
     // we can end up putting the FOAM_TITLE in place FOAM_TITLE_NON_EXISTENT_VARIABLE should be.
     const input = `
-      # \${FOAM_TITLE}
-      # $FOAM_TITLE
-      # \${FOAM_TITLE_NON_EXISTENT_VARIABLE}
-      # $FOAM_TITLE_NON_EXISTENT_VARIABLE
-    `;
+        # \${FOAM_TITLE}
+        # $FOAM_TITLE
+        # \${FOAM_TITLE_NON_EXISTENT_VARIABLE}
+        # $FOAM_TITLE_NON_EXISTENT_VARIABLE
+      `;
 
     const expected = `
-      # My note title
-      # My note title
-      # \${FOAM_TITLE_NON_EXISTENT_VARIABLE}
-      # $FOAM_TITLE_NON_EXISTENT_VARIABLE
-    `;
+        # My note title
+        # My note title
+        # \${FOAM_TITLE_NON_EXISTENT_VARIABLE}
+        # $FOAM_TITLE_NON_EXISTENT_VARIABLE
+      `;
 
     const givenValues = new Map<string, string>();
     givenValues.set('FOAM_TITLE', 'My note title');
     const resolver = new Resolver(givenValues, new Date());
-    expect((await resolver.resolveText(input))[1]).toEqual(expected);
+    expect(await resolver.resolveText(input)).toEqual(expected);
   });
 });
 
 describe('resolveFoamVariables', () => {
   test('Does nothing for unknown Foam-specific variables', async () => {
-    const variables = ['FOAM_FOO'];
+    const variables = [new Variable('FOAM_FOO')];
 
     const expected = new Map<string, string>();
-    expected.set('FOAM_FOO', 'FOAM_FOO');
 
     const givenValues = new Map<string, string>();
     const resolver = new Resolver(givenValues, new Date());
@@ -56,7 +69,7 @@ describe('resolveFoamVariables', () => {
 
   test('Resolves FOAM_TITLE', async () => {
     const foamTitle = 'My note title';
-    const variables = ['FOAM_TITLE'];
+    const variables = [new Variable('FOAM_TITLE'), new Variable('FOAM_SLUG')];
 
     jest
       .spyOn(window, 'showInputBox')
@@ -64,6 +77,7 @@ describe('resolveFoamVariables', () => {
 
     const expected = new Map<string, string>();
     expected.set('FOAM_TITLE', foamTitle);
+    expected.set('FOAM_SLUG', 'my-note-title');
 
     const givenValues = new Map<string, string>();
     const resolver = new Resolver(givenValues, new Date());
@@ -72,7 +86,7 @@ describe('resolveFoamVariables', () => {
 
   test('Resolves FOAM_TITLE without asking the user when it is provided', async () => {
     const foamTitle = 'My note title';
-    const variables = ['FOAM_TITLE'];
+    const variables = [new Variable('FOAM_TITLE')];
 
     const expected = new Map<string, string>();
     expected.set('FOAM_TITLE', foamTitle);
@@ -85,18 +99,18 @@ describe('resolveFoamVariables', () => {
 
   test('Resolves FOAM_DATE_* properties with current day by default', async () => {
     const variables = [
-      'FOAM_DATE_YEAR',
-      'FOAM_DATE_YEAR_SHORT',
-      'FOAM_DATE_MONTH',
-      'FOAM_DATE_MONTH_NAME',
-      'FOAM_DATE_MONTH_NAME_SHORT',
-      'FOAM_DATE_DATE',
-      'FOAM_DATE_DAY_NAME',
-      'FOAM_DATE_DAY_NAME_SHORT',
-      'FOAM_DATE_HOUR',
-      'FOAM_DATE_MINUTE',
-      'FOAM_DATE_SECOND',
-      'FOAM_DATE_SECONDS_UNIX',
+      new Variable('FOAM_DATE_YEAR'),
+      new Variable('FOAM_DATE_YEAR_SHORT'),
+      new Variable('FOAM_DATE_MONTH'),
+      new Variable('FOAM_DATE_MONTH_NAME'),
+      new Variable('FOAM_DATE_MONTH_NAME_SHORT'),
+      new Variable('FOAM_DATE_DATE'),
+      new Variable('FOAM_DATE_DAY_NAME'),
+      new Variable('FOAM_DATE_DAY_NAME_SHORT'),
+      new Variable('FOAM_DATE_HOUR'),
+      new Variable('FOAM_DATE_MINUTE'),
+      new Variable('FOAM_DATE_SECOND'),
+      new Variable('FOAM_DATE_SECONDS_UNIX'),
     ];
 
     const expected = new Map<string, string>();
@@ -123,18 +137,18 @@ describe('resolveFoamVariables', () => {
   test('Resolves FOAM_DATE_* properties with given date', async () => {
     const targetDate = new Date(2021, 9, 12, 1, 2, 3);
     const variables = [
-      'FOAM_DATE_YEAR',
-      'FOAM_DATE_YEAR_SHORT',
-      'FOAM_DATE_MONTH',
-      'FOAM_DATE_MONTH_NAME',
-      'FOAM_DATE_MONTH_NAME_SHORT',
-      'FOAM_DATE_DATE',
-      'FOAM_DATE_DAY_NAME',
-      'FOAM_DATE_DAY_NAME_SHORT',
-      'FOAM_DATE_HOUR',
-      'FOAM_DATE_MINUTE',
-      'FOAM_DATE_SECOND',
-      'FOAM_DATE_SECONDS_UNIX',
+      new Variable('FOAM_DATE_YEAR'),
+      new Variable('FOAM_DATE_YEAR_SHORT'),
+      new Variable('FOAM_DATE_MONTH'),
+      new Variable('FOAM_DATE_MONTH_NAME'),
+      new Variable('FOAM_DATE_MONTH_NAME_SHORT'),
+      new Variable('FOAM_DATE_DATE'),
+      new Variable('FOAM_DATE_DAY_NAME'),
+      new Variable('FOAM_DATE_DAY_NAME_SHORT'),
+      new Variable('FOAM_DATE_HOUR'),
+      new Variable('FOAM_DATE_MINUTE'),
+      new Variable('FOAM_DATE_SECOND'),
+      new Variable('FOAM_DATE_SECONDS_UNIX'),
     ];
 
     const expected = new Map<string, string>();
@@ -164,16 +178,14 @@ describe('resolveFoamVariables', () => {
 describe('resolveFoamTemplateVariables', () => {
   test('Does nothing for template without Foam-specific variables', async () => {
     const input = `
-      # \${AnotherVariable} <-- Unrelated to foam
-      # \${AnotherVariable:default_value} <-- Unrelated to foam
-      # \${AnotherVariable:default_value/(.*)/\${1:/upcase}/}} <-- Unrelated to foam
-      # $AnotherVariable} <-- Unrelated to foam
-      # $CURRENT_YEAR-\${CURRENT_MONTH}-$CURRENT_DAY <-- Unrelated to foam
-    `;
+        # \${AnotherVariable} <-- Unrelated to Foam
+        # \${AnotherVariable:default_value} <-- Unrelated to Foam
+        # \${AnotherVariable:default_value/(.*)/\${1:/upcase}/}} <-- Unrelated to Foam
+        # $AnotherVariable} <-- Unrelated to Foam
+        # $CURRENT_YEAR-\${CURRENT_MONTH}-$CURRENT_DAY <-- Unrelated to Foam
+      `;
 
-    const expectedMap = new Map<string, string>();
-    const expectedString = input;
-    const expected = [expectedMap, expectedString];
+    const expected = input;
 
     const resolver = new Resolver(new Map(), new Date());
     expect(await resolver.resolveText(input)).toEqual(expected);
@@ -181,48 +193,17 @@ describe('resolveFoamTemplateVariables', () => {
 
   test('Does nothing for unknown Foam-specific variables', async () => {
     const input = `
-      # $FOAM_FOO
-      # \${FOAM_FOO}
-      # \${FOAM_FOO:default_value}
-      # \${FOAM_FOO:default_value/(.*)/\${1:/upcase}/}}
-    `;
-
-    const expectedMap = new Map<string, string>();
-    const expectedString = input;
-    const expected = [expectedMap, expectedString];
+        # $FOAM_FOO
+        # \${FOAM_FOO}
+        # \${FOAM_FOO:default_value}
+        # \${FOAM_FOO:default_value/(.*)/\${1:/upcase}/}}
+      `;
 
+    const expected = input;
     const resolver = new Resolver(new Map(), new Date());
     expect(await resolver.resolveText(input)).toEqual(expected);
   });
 
-  test('Allows extra variables to be provided; only resolves the unique set', async () => {
-    const foamTitle = 'My note title';
-
-    jest
-      .spyOn(window, 'showInputBox')
-      .mockImplementationOnce(jest.fn(() => Promise.resolve(foamTitle)));
-
-    const input = `
-      # $FOAM_TITLE
-    `;
-
-    const expectedOutput = `
-      # My note title
-    `;
-
-    const expectedMap = new Map<string, string>();
-    expectedMap.set('FOAM_TITLE', foamTitle);
-
-    const expected = [expectedMap, expectedOutput];
-
-    const resolver = new Resolver(
-      new Map(),
-      new Date(),
-      new Set(['FOAM_TITLE'])
-    );
-    expect(await resolver.resolveText(input)).toEqual(expected);
-  });
-
   test('Appends FOAM_SELECTED_TEXT with a newline to the template if there is selected text but FOAM_SELECTED_TEXT is not referenced and the template ends in a newline', async () => {
     const foamTitle = 'My note title';
 
@@ -232,20 +213,11 @@ describe('resolveFoamTemplateVariables', () => {
 
     const input = `# \${FOAM_TITLE}\n`;
 
-    const expectedOutput = `# My note title\nSelected text\n`;
+    const expected = `# My note title\nSelected text\n`;
 
-    const expectedMap = new Map<string, string>();
-    expectedMap.set('FOAM_TITLE', foamTitle);
-    expectedMap.set('FOAM_SELECTED_TEXT', 'Selected text');
-
-    const expected = [expectedMap, expectedOutput];
     const givenValues = new Map<string, string>();
     givenValues.set('FOAM_SELECTED_TEXT', 'Selected text');
-    const resolver = new Resolver(
-      givenValues,
-      new Date(),
-      new Set(['FOAM_TITLE', 'FOAM_SELECTED_TEXT'])
-    );
+    const resolver = new Resolver(givenValues, new Date());
     expect(await resolver.resolveText(input)).toEqual(expected);
   });
 
@@ -258,20 +230,11 @@ describe('resolveFoamTemplateVariables', () => {
 
     const input = `# \${FOAM_TITLE}\n\n`;
 
-    const expectedOutput = `# My note title\n\nSelected text\n`;
+    const expected = `# My note title\n\nSelected text\n`;
 
-    const expectedMap = new Map<string, string>();
-    expectedMap.set('FOAM_TITLE', foamTitle);
-    expectedMap.set('FOAM_SELECTED_TEXT', 'Selected text');
-
-    const expected = [expectedMap, expectedOutput];
     const givenValues = new Map<string, string>();
     givenValues.set('FOAM_SELECTED_TEXT', 'Selected text');
-    const resolver = new Resolver(
-      givenValues,
-      new Date(),
-      new Set(['FOAM_TITLE', 'FOAM_SELECTED_TEXT'])
-    );
+    const resolver = new Resolver(givenValues, new Date());
     expect(await resolver.resolveText(input)).toEqual(expected);
   });
 
@@ -284,20 +247,11 @@ describe('resolveFoamTemplateVariables', () => {
 
     const input = `# \${FOAM_TITLE}`;
 
-    const expectedOutput = '# My note title\nSelected text';
+    const expected = '# My note title\nSelected text';
 
-    const expectedMap = new Map<string, string>();
-    expectedMap.set('FOAM_TITLE', foamTitle);
-    expectedMap.set('FOAM_SELECTED_TEXT', 'Selected text');
-
-    const expected = [expectedMap, expectedOutput];
     const givenValues = new Map<string, string>();
     givenValues.set('FOAM_SELECTED_TEXT', 'Selected text');
-    const resolver = new Resolver(
-      givenValues,
-      new Date(),
-      new Set(['FOAM_TITLE', 'FOAM_SELECTED_TEXT'])
-    );
+    const resolver = new Resolver(givenValues, new Date());
     expect(await resolver.resolveText(input)).toEqual(expected);
   });
 
@@ -309,25 +263,15 @@ describe('resolveFoamTemplateVariables', () => {
       .mockImplementationOnce(jest.fn(() => Promise.resolve(foamTitle)));
 
     const input = `
-      # \${FOAM_TITLE}
-      `;
+        # \${FOAM_TITLE}
+        `;
 
-    const expectedOutput = `
-      # My note title
-      `;
+    const expected = `
+        # My note title
+        `;
 
-    const expectedMap = new Map<string, string>();
-    expectedMap.set('FOAM_TITLE', foamTitle);
-    expectedMap.set('FOAM_SELECTED_TEXT', '');
-
-    const expected = [expectedMap, expectedOutput];
     const givenValues = new Map<string, string>();
-    givenValues.set('FOAM_SELECTED_TEXT', '');
-    const resolver = new Resolver(
-      givenValues,
-      new Date(),
-      new Set(['FOAM_TITLE', 'FOAM_SELECTED_TEXT'])
-    );
+    const resolver = new Resolver(givenValues, new Date());
     expect(await resolver.resolveText(input)).toEqual(expected);
   });
 });

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

@@ -1,9 +1,16 @@
 import { findSelectionContent } from './editor';
 import { window } from 'vscode';
 import { UserCancelledOperation } from './errors';
+import { toSlug } from '../utils/slug';
+import {
+  SnippetParser,
+  Variable,
+  VariableResolver,
+} from '../core/common/snippetParser';
 
 const knownFoamVariables = new Set([
   'FOAM_TITLE',
+  'FOAM_SLUG',
   'FOAM_SELECTED_TEXT',
   'FOAM_DATE_YEAR',
   'FOAM_DATE_YEAR_SHORT',
@@ -19,54 +26,17 @@ const knownFoamVariables = new Set([
   'FOAM_DATE_SECONDS_UNIX',
 ]);
 
-export function substituteVariables(
-  text: string,
-  variables: Map<string, string>
-) {
-  variables.forEach((value, variable) => {
-    const regex = new RegExp(
-      // Matches a limited subset of the the TextMate variable syntax:
-      //  ${VARIABLE}  OR   $VARIABLE
-      `\\\${${variable}}|\\$${variable}(\\W|$)`,
-      // The latter is more complicated, since it needs to avoid replacing
-      // longer variable names with the values of variables that are
-      // substrings of the longer ones (e.g. `$FOO` and `$FOOBAR`. If you
-      // replace $FOO first, and aren't careful, you replace the first
-      // characters of `$FOOBAR`)
-      'g' // 'g' => Global replacement (i.e. not just the first instance)
-    );
-    text = text.replace(regex, `${value}$1`);
-  });
-
-  return text;
-}
-
-export function findFoamVariables(templateText: string): string[] {
-  const regex = /\$(FOAM_[_a-zA-Z0-9]*)|\${(FOAM_[[_a-zA-Z0-9]*)}/g;
-  var matches = [];
-  const output: string[] = [];
-  while ((matches = regex.exec(templateText))) {
-    output.push(matches[1] || matches[2]);
-  }
-  const uniqVariables = [...new Set(output)];
-  const knownVariables = uniqVariables.filter(x => knownFoamVariables.has(x));
-  return knownVariables;
-}
-
-export class Resolver {
-  promises = new Map<string, Thenable<string>>();
-
+export class Resolver implements VariableResolver {
+  private promises = new Map<string, Promise<string | undefined>>();
   /**
    * Create a resolver
    *
    * @param givenValues the map of variable name to value
    * @param foamDate the date used to fill FOAM_DATE_* variables
-   * @param extraVariablesToResolve other variables to always resolve, even if not present in text
    */
   constructor(
     private givenValues: Map<string, string>,
-    private foamDate: Date,
-    private extraVariablesToResolve: Set<string> = new Set()
+    private foamDate: Date
   ) {}
 
   /**
@@ -86,31 +56,38 @@ export class Resolver {
    * @returns an array, where the first element is the resolution map,
    *          and the second is the processed text
    */
-  async resolveText(text: string): Promise<[Map<string, string>, string]> {
-    const variablesInTemplate = findFoamVariables(text.toString());
-    const variables = variablesInTemplate.concat(
-      ...this.extraVariablesToResolve
+  async resolveText(text: string): Promise<string> {
+    let snippet = new SnippetParser().parse(text, false, false);
+    let foamVariablesInTemplate = new Set(
+      snippet
+        .variables()
+        .map(v => v.name)
+        .filter(name => knownFoamVariables.has(name))
     );
-    const uniqVariables = [...new Set(variables)];
-
-    const resolvedValues = await this.resolveAll(uniqVariables);
 
+    // Add FOAM_SELECTED_TEXT to the template text if required
+    // and re-parse the template text.
     if (
-      resolvedValues.get('FOAM_SELECTED_TEXT') &&
-      !variablesInTemplate.includes('FOAM_SELECTED_TEXT')
+      this.givenValues.has('FOAM_SELECTED_TEXT') &&
+      !foamVariablesInTemplate.has('FOAM_SELECTED_TEXT')
     ) {
-      text = text.endsWith('\n')
-        ? `${text}\${FOAM_SELECTED_TEXT}\n`
-        : `${text}\n\${FOAM_SELECTED_TEXT}`;
-
-      variablesInTemplate.push('FOAM_SELECTED_TEXT');
-      variables.push('FOAM_SELECTED_TEXT');
-      uniqVariables.push('FOAM_SELECTED_TEXT');
+      const token = '$FOAM_SELECTED_TEXT';
+      if (text.endsWith('\n')) {
+        text = `${text}${token}\n`;
+      } else {
+        text = `${text}\n${token}`;
+      }
+      snippet = new SnippetParser().parse(text, false, false);
+      foamVariablesInTemplate = new Set(
+        snippet
+          .variables()
+          .map(v => v.name)
+          .filter(name => knownFoamVariables.has(name))
+      );
     }
 
-    const subbedText = substituteVariables(text.toString(), resolvedValues);
-
-    return [resolvedValues, subbedText];
+    await snippet.resolveVariables(this, foamVariablesInTemplate);
+    return snippet.snippetTextWithVariablesSubstituted(foamVariablesInTemplate);
   }
 
   /**
@@ -119,19 +96,16 @@ export class Resolver {
    * @param variables a list of variables to resolve
    * @returns a Map of variable name to its value
    */
-  async resolveAll(variables: string[]): Promise<Map<string, string>> {
-    const promises = variables.map(async variable =>
-      Promise.resolve([variable, await this.resolve(variable)])
-    );
+  async resolveAll(variables: Variable[]): Promise<Map<string, string>> {
+    await Promise.all(variables.map(variable => variable.resolve(this)));
 
-    const results = await Promise.all(promises);
-
-    const valueByName = new Map<string, string>();
-    results.forEach(([variable, value]) => {
-      valueByName.set(variable, value);
+    const resolvedValues = new Map<string, string>();
+    variables.forEach(variable => {
+      if (variable.children.length > 0) {
+        resolvedValues.set(variable.name, variable.toString());
+      }
     });
-
-    return valueByName;
+    return resolvedValues;
   }
 
   /**
@@ -140,132 +114,92 @@ export class Resolver {
    * @param name the variable name
    * @returns the resolved value, or the name of the variable if nothing is found
    */
-  resolve(name: string): Thenable<string> {
+  async resolveFromName(name: string): Promise<string> {
+    const variable = new Variable(name);
+    await variable.resolve(this);
+
+    return (variable.children[0] ?? name).toString();
+  }
+
+  async resolve(variable: Variable): Promise<string | undefined> {
+    const name = variable.name;
     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':
+          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(name));
+          value = Promise.resolve(undefined);
           break;
       }
+      this.promises.set(name, value);
     }
     const result = this.promises.get(name);
     return result;

packages/foam-vscode/src/test/run-tests.ts

@@ -1,5 +1,3 @@
-import fs from 'fs';
-import os from 'os';
 import path from 'path';
 import { runTests } from 'vscode-test';
 import { runUnit } from './suite-unit';
@@ -35,23 +33,17 @@ async function main() {
       // The path to the extension test script
       // Passed to --extensionTestsPath
       const extensionTestsPath = path.join(__dirname, 'suite');
-      const tmpWorkspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'foam-'));
 
       // Download VS Code, unzip it and run the integration test
       await runTests({
         extensionDevelopmentPath,
         extensionTestsPath,
         launchArgs: [
-          tmpWorkspaceDir,
+          path.join(extensionDevelopmentPath, '.test-workspace'),
           '--disable-extensions',
           '--disable-workspace-trust',
         ],
-        // Running the tests with vscode 1.53.0 is causing issues in the output/error stream management,
-        // which is causing a stack overflow, possibly due to a recursive callback.
-        // Also see https://github.com/foambubble/foam/pull/479#issuecomment-774167127
-        // Forcing the version to 1.52.0 solves the problem.
-        // TODO: to review, further investigate, and roll back this workaround.
-        version: '1.52.0',
+        version: '1.60.0',
       });
     } catch (err) {
       console.log('Error occurred while running Foam e2e tests:', err);

packages/foam-vscode/src/test/suite-unit.ts

@@ -8,32 +8,30 @@
  *   they will make direct use of the vscode API to be invoked as commands, create editors,
  *   and so on..
  */
-import path from 'path';
+
+/* eslint-disable import/first */
+
+// Set before imports, see https://github.com/facebook/jest/issues/12162
+process.env.FORCE_COLOR = '1';
+process.env.NODE_ENV = 'test';
+
+// eslint-disable-next-line import/no-extraneous-dependencies
 import { runCLI } from '@jest/core';
+import path from 'path';
 
 const rootDir = path.join(__dirname, '..', '..');
 
 export function runUnit(): Promise<void> {
-  process.env.FORCE_COLOR = '1';
-  process.env.NODE_ENV = 'test';
-  process.env.BABEL_ENV = 'test';
-
+  // eslint-disable-next-line no-async-promise-executor
   return new Promise(async (resolve, reject) => {
     try {
       const { results } = await runCLI(
         {
           rootDir,
           roots: ['<rootDir>/src'],
-          transform: JSON.stringify({ '^.+\\.ts$': 'ts-jest' }),
           runInBand: true,
           testRegex: '\\.(test)\\.ts$',
           setupFiles: ['<rootDir>/src/test/support/jest-setup.ts'],
-          setupFilesAfterEnv: ['jest-extended'],
-          globals: JSON.stringify({
-            'ts-jest': {
-              tsconfig: path.join(rootDir, 'tsconfig.json'),
-            },
-          }),
           testTimeout: 20000,
           verbose: false,
           silent: false,

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

@@ -9,42 +9,48 @@
  *   and so on..
  */
 
-import path from 'path';
-import { runCLI } from '@jest/core';
+/* eslint-disable import/first */
 
-const rootDir = path.resolve(__dirname, '../..');
+// Set before imports, see https://github.com/facebook/jest/issues/12162
+process.env.FORCE_COLOR = '1';
+process.env.NODE_ENV = 'test';
+
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { runCLI } from '@jest/core';
+import { cleanWorkspace } from './test-utils-vscode';
+import path from 'path';
+
+const rootDir = path.join(__dirname, '../..');
 
 export function run(): Promise<void> {
   const errWrite = process.stderr.write;
+
+  let remaining = '';
   process.stderr.write = (buffer: string) => {
-    console.log(buffer);
+    const lines = (remaining + buffer).split('\n');
+    remaining = lines.pop() as string;
+    // Trim long lines because some uninformative code dumps will flood the
+    // console or, worse, be suppressed altogether because of their size.
+    lines.forEach(l => console.log(l.substr(0, 300)));
     return true;
   };
+
   // process.on('unhandledRejection', err => {
   //   throw err;
   // });
-  process.env.FORCE_COLOR = '1';
-  process.env.NODE_ENV = 'test';
-  process.env.BABEL_ENV = 'test';
 
+  // eslint-disable-next-line no-async-promise-executor
   return new Promise(async (resolve, reject) => {
+    await cleanWorkspace();
     try {
       const { results } = await runCLI(
         {
           rootDir,
           roots: ['<rootDir>/src'],
-          transform: JSON.stringify({ '^.+\\.ts$': 'ts-jest' }),
           runInBand: true,
           testRegex: '\\.(test|spec)\\.ts$',
-          testEnvironment:
-            '<rootDir>/src/test/support/extended-vscode-environment.js',
+          testEnvironment: '<rootDir>/src/test/support/vscode-environment.js',
           setupFiles: ['<rootDir>/src/test/support/jest-setup.ts'],
-          setupFilesAfterEnv: ['jest-extended'],
-          globals: JSON.stringify({
-            'ts-jest': {
-              tsconfig: path.resolve(rootDir, './tsconfig.json'),
-            },
-          }),
           testTimeout: 30000,
           useStderr: true,
           verbose: true,
@@ -71,6 +77,7 @@ export function run(): Promise<void> {
       return reject(error);
     } finally {
       process.stderr.write = errWrite.bind(process.stderr);
+      await cleanWorkspace();
     }
   });
 }

packages/foam-vscode/src/test/support/vscode-environment.js

@@ -1,27 +1,27 @@
-// Based on https://github.com/svsool/vscode-memo/blob/master/src/test/env/ExtendedVscodeEnvironment.js
-const VscodeEnvironment = require('jest-environment-vscode');
+const NodeEnvironment = require('jest-environment-node');
 const vscode = require('vscode');
 
-const initialVscode = vscode;
-class ExtendedVscodeEnvironment extends VscodeEnvironment {
+class VscodeEnvironment extends NodeEnvironment {
   async setup() {
     await super.setup();
+    this.global.vscode = vscode;
+
     // Expose RegExp otherwise document.getWordRangeAtPosition won't work as supposed.
     // Implementation of getWordRangeAtPosition uses "instanceof RegExp" which returns false
     // due to Jest running tests in the different vm context.
     // See https://github.com/nodejs/node-v0.x-archive/issues/1277.
     // And also https://github.com/microsoft/vscode-test/issues/37#issuecomment-700167820
     this.global.RegExp = RegExp;
-    this.global.vscode = vscode;
 
     vscode.workspace
       .getConfiguration()
       .update('foam.edit.linkReferenceDefinitions', 'off');
   }
+
   async teardown() {
-    this.global.vscode = initialVscode;
+    this.global.vscode = {};
     await super.teardown();
   }
 }
 
-module.exports = ExtendedVscodeEnvironment;
+module.exports = VscodeEnvironment;

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';
@@ -13,7 +13,7 @@ import { randomString, wait } from './test-utils';
 Logger.setLevel('error');
 
 export const cleanWorkspace = async () => {
-  const files = await vscode.workspace.findFiles('**', '.vscode');
+  const files = await vscode.workspace.findFiles('**', '{.vscode,.keep}');
   await Promise.all(files.map(f => vscode.workspace.fs.delete(f)));
 };
 
@@ -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) => {
-  let content = `# ${r.title}
+  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})`,
               };
         })
       : [],
@@ -109,3 +108,6 @@ export const randomString = (len = 5) =>
     .fill('')
     .map(() => chars.charAt(Math.floor(Math.random() * chars.length)))
     .join('');
+
+export const getRandomURI = () =>
+  URI.file('/random-uri-root/' + randomString() + '.md');

packages/foam-vscode/src/utils.ts

@@ -26,7 +26,7 @@ export const mdDocSelector = [
 
 export function loadDocConfig() {
   // Load workspace config
-  let activeEditor = window.activeTextEditor;
+  const activeEditor = window.activeTextEditor;
   if (!activeEditor) {
     Logger.debug('Failed to load config, no active editor');
     return;
@@ -34,8 +34,8 @@ export function loadDocConfig() {
 
   docConfig.eol = activeEditor.document.eol === EndOfLine.CRLF ? '\r\n' : '\n';
 
-  let tabSize = Number(activeEditor.options.tabSize);
-  let insertSpaces = activeEditor.options.insertSpaces;
+  const tabSize = Number(activeEditor.options.tabSize);
+  const insertSpaces = activeEditor.options.insertSpaces;
   if (insertSpaces) {
     docConfig.tab = ' '.repeat(tabSize);
   } else {
@@ -133,7 +133,7 @@ export function isSome<T>(
   value: T | null | undefined | void
 ): value is NonNullable<T> {
   //
-  return value != null; // eslint-disable-line
+  return value != null;
 }
 
 /**
@@ -144,7 +144,7 @@ export function isSome<T>(
 export function isNone<T>(
   value: T | null | undefined | void
 ): value is null | undefined | void {
-  return value == null; // eslint-disable-line
+  return value == null;
 }
 
 export async function focusNote(
@@ -161,6 +161,8 @@ export async function focusNote(
     const { range } = editor.document.lineAt(lineCount - 1);
     editor.selection = new Selection(range.end, range.end);
   }
+
+  return { document, editor };
 }
 
 export function getContainsTooltip(titles: string[]): string {

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

@@ -0,0 +1,3 @@
+import slugger from 'github-slugger';
+
+export const toSlug = (s: string) => slugger.slug(s);

packages/foam-vscode/syntaxes/injection.json

@@ -0,0 +1,11 @@
+{
+  "scopeName": "foam.wikilink.injection",
+  "injectionSelector": "L:meta.paragraph.markdown",
+  "patterns": [
+    {
+      "contentName": "string.other.link.title.markdown.foam",
+      "begin": "\\[\\[",
+      "end": "\\]\\]"
+    }
+  ]
+}

readme.md

@@ -5,7 +5,7 @@
 👀*This is an early stage project under rapid development. For updates join the [Foam community Discord](https://foambubble.github.io/join-discord/g)! 💬*
 
 <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
-[![All Contributors](https://img.shields.io/badge/all_contributors-87-orange.svg?style=flat-square)](#contributors-)
+[![All Contributors](https://img.shields.io/badge/all_contributors-94-orange.svg?style=flat-square)](#contributors-)
 <!-- ALL-CONTRIBUTORS-BADGE:END -->
 
 [![Discord Chat](https://img.shields.io/discord/729975036148056075?color=748AD9&label=discord%20chat&style=flat-square)](https://foambubble.github.io/join-discord/g)
@@ -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.
@@ -302,6 +308,15 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d
     <td align="center"><a href="https://github.com/AndreiD049"><img src="https://avatars.githubusercontent.com/u/52671223?v=4?s=60" width="60px;" alt=""/><br /><sub><b>AndreiD049</b></sub></a><br /><a href="https://github.com/foambubble/foam/commits?author=AndreiD049" title="Code">💻</a></td>
     <td align="center"><a href="https://github.com/iam-yan"><img src="https://avatars.githubusercontent.com/u/48427014?v=4?s=60" width="60px;" alt=""/><br /><sub><b>Yan</b></sub></a><br /><a href="https://github.com/foambubble/foam/commits?author=iam-yan" title="Documentation">📖</a></td>
     <td align="center"><a href="https://WikiEducator.org/User:JimTittsler"><img src="https://avatars.githubusercontent.com/u/180326?v=4?s=60" width="60px;" alt=""/><br /><sub><b>Jim Tittsler</b></sub></a><br /><a href="https://github.com/foambubble/foam/commits?author=jimt" title="Documentation">📖</a></td>
+    <td align="center"><a href="http://malcolmmielle.wordpress.com/"><img src="https://avatars.githubusercontent.com/u/4457840?v=4?s=60" width="60px;" alt=""/><br /><sub><b>Malcolm Mielle</b></sub></a><br /><a href="https://github.com/foambubble/foam/commits?author=MalcolmMielle" title="Documentation">📖</a></td>
+    <td align="center"><a href="https://snippets.page/"><img src="https://avatars.githubusercontent.com/u/74916913?v=4?s=60" width="60px;" alt=""/><br /><sub><b>Veesar</b></sub></a><br /><a href="https://github.com/foambubble/foam/commits?author=veesar" title="Documentation">📖</a></td>
+    <td align="center"><a href="https://github.com/bentongxyz"><img src="https://avatars.githubusercontent.com/u/60358804?v=4?s=60" width="60px;" alt=""/><br /><sub><b>bentongxyz</b></sub></a><br /><a href="https://github.com/foambubble/foam/commits?author=bentongxyz" title="Code">💻</a></td>
+    <td align="center"><a href="https://brianjdevries.com"><img src="https://avatars.githubusercontent.com/u/42778030?v=4?s=60" width="60px;" alt=""/><br /><sub><b>Brian DeVries</b></sub></a><br /><a href="https://github.com/foambubble/foam/commits?author=techCarpenter" title="Code">💻</a></td>
+  </tr>
+  <tr>
+    <td align="center"><a href="http://Cliffordfajardo.com"><img src="https://avatars.githubusercontent.com/u/6743796?v=4?s=60" width="60px;" alt=""/><br /><sub><b>Clifford Fajardo </b></sub></a><br /><a href="#tool-cliffordfajardo" title="Tools">🔧</a></td>
+    <td align="center"><a href="http://cu-dev.ca"><img src="https://avatars.githubusercontent.com/u/6589365?v=4?s=60" width="60px;" alt=""/><br /><sub><b>Chris Usick</b></sub></a><br /><a href="https://github.com/foambubble/foam/commits?author=chrisUsick" title="Code">💻</a></td>
+    <td align="center"><a href="https://github.com/josephdecock"><img src="https://avatars.githubusercontent.com/u/1145533?v=4?s=60" width="60px;" alt=""/><br /><sub><b>Joe DeCock</b></sub></a><br /><a href="https://github.com/foambubble/foam/commits?author=josephdecock" title="Code">💻</a></td>
   </tr>
 </table>