@platformos/platformos-language-server-common 0.0.2

package/src/formatting/providers/BracketsAutoclosingOnTypeFormattingProvider.spec.ts

@@ -0,0 +1,88 @@
+import { assert, beforeEach, describe, expect, it } from 'vitest';
+import { DocumentOnTypeFormattingParams } from 'vscode-languageserver';
+import { Position } from 'vscode-languageserver-protocol';
+import { DocumentManager } from '../../documents';
+import { OnTypeFormattingProvider } from '../OnTypeFormattingProvider';
+
+const options: DocumentOnTypeFormattingParams['options'] = {
+  insertSpaces: true,
+  tabSize: 2,
+};
+
+describe('Module: BracketsAutoclosingOnTypeFormattingProvider', () => {
+  let documentManager: DocumentManager;
+  let onTypeFormattingProvider: OnTypeFormattingProvider;
+
+  beforeEach(() => {
+    documentManager = new DocumentManager();
+    onTypeFormattingProvider = new OnTypeFormattingProvider(documentManager);
+  });
+
+  it('should return a TextEdit to insert a space after "{{" in "{{ }}"', async () => {
+    const params: DocumentOnTypeFormattingParams = {
+      textDocument: { uri: 'file:///path/to/document.liquid' },
+      position: Position.create(0, 2),
+      ch: '{',
+      options,
+    };
+
+    documentManager.open(params.textDocument.uri, '{{ }}', 1);
+    const document = documentManager.get(params.textDocument.uri)?.textDocument;
+    assert(document);
+
+    const result = await onTypeFormattingProvider.onTypeFormatting(params);
+    assert(result);
+    expect(result).to.applyEdits(document, '{{  }}');
+  });
+
+  it('should return a TextEdit to insert a space after "{%" in "{% %}"', async () => {
+    const params: DocumentOnTypeFormattingParams = {
+      textDocument: { uri: 'file:///path/to/document.liquid' },
+      position: Position.create(0, 2),
+      ch: '%',
+      options,
+    };
+
+    documentManager.open(params.textDocument.uri, '{% %}', 1);
+    const document = documentManager.get(params.textDocument.uri)?.textDocument;
+    assert(document);
+
+    const result = await onTypeFormattingProvider.onTypeFormatting(params);
+    assert(result);
+    expect(result).to.applyEdits(document, '{%  %}');
+  });
+
+  it('should return a TextEdit to replace and insert characters in "{{ - }}"', async () => {
+    const params: DocumentOnTypeFormattingParams = {
+      textDocument: { uri: 'file:///path/to/document.liquid' },
+      position: Position.create(0, 4),
+      ch: '-',
+      options,
+    };
+
+    documentManager.open(params.textDocument.uri, '{{ - }}', 1);
+    const document = documentManager.get(params.textDocument.uri)?.textDocument;
+    assert(document);
+
+    const result = await onTypeFormattingProvider.onTypeFormatting(params);
+    assert(result);
+    expect(result).to.applyEdits(document, '{{-  -}}');
+  });
+
+  it('should return a TextEdit to replace and insert characters in "{% - %}"', async () => {
+    const params: DocumentOnTypeFormattingParams = {
+      textDocument: { uri: 'file:///path/to/document.liquid' },
+      position: Position.create(0, 4),
+      ch: '-',
+      options,
+    };
+
+    documentManager.open(params.textDocument.uri, '{% - %}', 1);
+    const document = documentManager.get(params.textDocument.uri)?.textDocument;
+    assert(document);
+
+    const result = await onTypeFormattingProvider.onTypeFormatting(params);
+    assert(result);
+    expect(result).to.applyEdits(document, '{%-  -%}');
+  });
+});

package/src/formatting/providers/BracketsAutoclosingOnTypeFormattingProvider.ts

@@ -0,0 +1,114 @@
+import {
+  Range,
+  DocumentOnTypeFormattingParams,
+  TextEdit,
+  Position,
+} from 'vscode-languageserver-protocol';
+import { AugmentedSourceCode } from '../../documents';
+import { BaseOnTypeFormattingProvider } from '../types';
+
+export class BracketsAutoclosingOnTypeFormattingProvider implements BaseOnTypeFormattingProvider {
+  /**
+   * This very complex piece of code here exists to provide a good autoclosing UX.
+   *
+   * The story is kind of long so here goes...
+   *
+   * What we want:
+   * 1. Basic autoclosing of {{, {% with the corresponding pair (and spaces)
+   *   - user types: {{
+   *   - user sees: {{ | }} (with cursor position at |)
+   * 2. Autoclosing of {{- with -}}, {%- with -%}
+   *   - user types: {{-
+   *   - user sees: {{- | -}} (with cursor at |)
+   * 3. User adds whitespace stripping on one side of the braces of an existing tag
+   *   - user types: - at | in `{{| drop }}`
+   *   - user sees: {{- drop }}
+   *
+   * Why we can't do it with autoclosingPairs:
+   *   - VS Code's settings accepts autoclosingPairs and autocloseBefore
+   *     - autoclosingPairs is a set of pairs that should be autoclosed (e.g. ['{%', '%}'])
+   *     - autocloseBefore is a character set of 'allowed next characters' that would cause a closing pair
+   *   - If we put a space (' ') the autoclosingPairs set, then (3) from above becomes funky:
+   *     - assume autoclosingPairs = {|}, {{|}}, {{ | }}
+   *     - user types: a space at | in `{{| drop }}`
+   *     - user sees: {{   }}drop }}
+   *   - This happens because the space is an autocloseBefore character, it sees a space after the cursor
+   *     so it closes '{{ ' with ' }}' at the cursor position, resulting in '{{  }}drop }}'
+   *   - Something similar happens if we include the `-` in the autoclosing pairs
+   *   - This is annoying!
+   *
+   * So our solution is the following:
+   * 1. We change the pairs to include the closing space (this way our cursor remains where we want it to be)
+   *    - {{| }}
+   *    - {%| %}
+   * 2. We add this OnTypeFormattingProvider that does the following "fixes":
+   *    - {{| }}   into {{ | }}
+   *    - {{ -| }} into {{- | -}}
+   *    - {%| %}   into {% | %}
+   *    - {% -| %} into {%- | -%}
+   *
+   * This lets us avoid the unnecessary close and accomplish 1, 2 and 3 :)
+   *
+   * Fallback for editor.onTypeFormatting: false is to let the user type the `-` on both sides manually
+   */
+  onTypeFormatting(
+    document: AugmentedSourceCode,
+    params: DocumentOnTypeFormattingParams,
+  ): TextEdit[] | null {
+    const textDocument = document.textDocument;
+    const ch = params.ch;
+    // position is position of cursor so 1 ahead of char
+    const { line, character } = params.position;
+    // This is an early return to avoid doing currentLine.at(-1);
+    if ((ch === ' ' && character <= 2) || character <= 1) return null;
+    const currentLineRange = Range.create(Position.create(line, 0), Position.create(line + 1, 0));
+    const currentLine = textDocument.getText(currentLineRange);
+    const charIdx = ch === ' ' ? character - 2 : character - 1;
+    const char = currentLine.at(charIdx);
+    switch (char) {
+      // here we fix {{| }} with {{ | }}
+      // here we fix {%| %} with {% | %}
+      case '{':
+      case '%': {
+        const chars = currentLine.slice(charIdx - 1, charIdx + 4);
+        if (chars === '{{ }}' || chars === '{% %}') {
+          return [TextEdit.insert(Position.create(line, charIdx + 1), ' ')];
+        }
+      }
+
+      // here we fix {{ -| }} to {{- | -}}
+      // here we fix {% -| }} to {%- | -%}
+      case '-': {
+        // remember 0-index means 4th char
+        if (charIdx < 3) return null;
+
+        const chars = currentLine.slice(charIdx - 3, charIdx + 4);
+        if (chars === '{{ - }}' || chars === '{% - %}') {
+          // Here we're being clever and doing the {{- -}} if the first character
+          // you type is a `-`, leaving your cursor in the middle :)
+          return [
+            // Start with
+            //   {{ - }}
+            //     ^ start replace
+            //       ^ end replace (excluded)
+            // Replace with '- ', get
+            //   {{- }}
+            TextEdit.replace(
+              Range.create(Position.create(line, charIdx - 1), Position.create(line, charIdx + 1)),
+              '- ',
+            ),
+            // Start with
+            //   {{ - }}
+            //      ^ char
+            //        ^ insertion point
+            // Insert ' ' , get
+            //   {{ - -}}
+            // Both together and you get {{- -}} with your cursor in the middle
+            TextEdit.insert(Position.create(line, charIdx + 2), '-'),
+          ];
+        }
+      }
+    }
+    return null;
+  }
+}

package/src/formatting/providers/HtmlElementAutoclosingOnTypeFormattingProvider.spec.ts

@@ -0,0 +1,183 @@
+import { afterEach, assert, beforeEach, describe, expect, it, vi } from 'vitest';
+import { DocumentOnTypeFormattingParams } from 'vscode-languageserver';
+import { DocumentManager } from '../../documents';
+import { OnTypeFormattingProvider } from '../OnTypeFormattingProvider';
+
+const options: DocumentOnTypeFormattingParams['options'] = {
+  insertSpaces: true,
+  tabSize: 2,
+};
+
+describe('Module: HtmlElementAutoclosingOnTypeFormattingProvider', () => {
+  let documentManager: DocumentManager;
+  let onTypeFormattingProvider: OnTypeFormattingProvider;
+  let setCursorPositionSpy: ReturnType<typeof vi.fn>;
+  const uri = 'file:///path/to/document.liquid';
+
+  beforeEach(() => {
+    setCursorPositionSpy = vi.fn();
+    documentManager = new DocumentManager();
+    onTypeFormattingProvider = new OnTypeFormattingProvider(documentManager, setCursorPositionSpy);
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('should return a TextEdit to insert a closing <tag> when you type > for an unclosed tag', async () => {
+    const source = '<div id="main">';
+    documentManager.open(uri, source, 1);
+    const document = documentManager.get(uri)?.textDocument!;
+
+    const params: DocumentOnTypeFormattingParams = {
+      textDocument: { uri },
+      position: document.positionAt(source.indexOf('>') + 1),
+      ch: '>',
+      options,
+    };
+
+    assert(document);
+
+    const result = await onTypeFormattingProvider.onTypeFormatting(params);
+    assert(result);
+    expect(result).to.applyEdits(document, '<div id="main"></div>');
+
+    vi.advanceTimersByTime(10);
+    expect(setCursorPositionSpy).toHaveBeenCalledWith(
+      document,
+      document.positionAt(source.indexOf('>') + 1),
+    );
+  });
+
+  it('should return a TextEdit to insert a closing <tag> when you type > for an unclosed tag even if the unclosed tag is higher up', async () => {
+    const CURSOR = '█';
+    // in this scenario, the cursor is after div#inner, but the unclosed tag is div#main.
+    // we still want to close it because that's probably what you want to do.
+    const source = `
+      <div id="main">
+        <img>
+        <div id="inner">█
+      </div>
+    `;
+    const expected = `
+      <div id="main">
+        <img>
+        <div id="inner"></div>
+      </div>
+    `;
+    documentManager.open(uri, source.replace(CURSOR, ''), 1);
+    const document = documentManager.get(uri)?.textDocument!;
+
+    const indexOfCursor = source.indexOf(CURSOR);
+    const params: DocumentOnTypeFormattingParams = {
+      textDocument: { uri },
+      position: document.positionAt(indexOfCursor),
+      ch: '>',
+      options,
+    };
+
+    assert(document);
+
+    const result = await onTypeFormattingProvider.onTypeFormatting(params);
+    assert(result);
+    expect(result).to.applyEdits(document, expected);
+
+    vi.advanceTimersByTime(10);
+    expect(setCursorPositionSpy).toHaveBeenCalledWith(document, document.positionAt(indexOfCursor));
+  });
+
+  it('should return a TextEdit to insert a closing <tag> when you type > for an unclosed tag even if the unclosed tag is higher up and theres a sibling closed tag', async () => {
+    const CURSOR = '█';
+    // in this scenario, the cursor is after div#inner, but the unclosed tag is div#main.
+    // we still want to close it because that's probably what you want to do.
+    const source = `
+      <div id="main">
+        <div id="inner">█
+        <div></div>
+      </div>
+    `;
+    const expected = `
+      <div id="main">
+        <div id="inner"></div>
+        <div></div>
+      </div>
+    `;
+    documentManager.open(uri, source.replace(CURSOR, ''), 1);
+    const document = documentManager.get(uri)?.textDocument!;
+
+    const indexOfCursor = source.indexOf(CURSOR);
+    const params: DocumentOnTypeFormattingParams = {
+      textDocument: { uri },
+      position: document.positionAt(indexOfCursor),
+      ch: '>',
+      options,
+    };
+
+    assert(document);
+
+    const result = await onTypeFormattingProvider.onTypeFormatting(params);
+    assert(result);
+    expect(result).to.applyEdits(document, expected);
+
+    vi.advanceTimersByTime(10);
+    expect(setCursorPositionSpy).toHaveBeenCalledWith(document, document.positionAt(indexOfCursor));
+  });
+
+  it('should try to close dangling html open tags inside liquid branches', async () => {
+    const CURSOR = '█';
+    const scenarios = [
+      '{% if cond %}<div>█{% endif %}',
+      '{% if cond %}{% else %}<div>█{% endif %}',
+      '{% if cond %}<div></div>{% else %}<div>█{% endif %}',
+      '{% if cond %}<div></div>{% elsif cond %}<div>█{% else %}<div>{% endif %}',
+      '{% if cond %}<div></div>{% elsif cond %}<div>█ {% else %}<div>{% endif %}',
+      '{% unless cond %}<div>█{% endunless %}',
+      '{% unless cond %}<div><div>█{% endunless %}',
+      '{% case thing %}{% when thing %}<div>█{% endif %}',
+    ];
+    for (const source of scenarios) {
+      documentManager.open(uri, source.replace(CURSOR, ''), 1);
+      const document = documentManager.get(uri)?.textDocument!;
+      const indexOfCursor = source.indexOf(CURSOR);
+      const params: DocumentOnTypeFormattingParams = {
+        textDocument: { uri },
+        position: document.positionAt(indexOfCursor),
+        ch: '>',
+        options,
+      };
+      assert(document);
+      const result = await onTypeFormattingProvider.onTypeFormatting(params);
+      assert(result, 'expected results for source:\n' + source);
+      expect(result).to.applyEdits(document, source.replace(CURSOR, '</div>'));
+
+      vi.advanceTimersByTime(10);
+      expect(setCursorPositionSpy).toHaveBeenCalledWith(
+        document,
+        document.positionAt(indexOfCursor),
+      );
+    }
+  });
+
+  it('should not try to close the tag when pressing > inside a Liquid tag if condition (what HTML would do)', async () => {
+    const CURSOR = '█';
+    const scenarios = ['<div {% if cond >█', '<div {% if cond >█ %}>', '<div {% if cond >█ 2 %}>'];
+    for (const source of scenarios) {
+      documentManager.open(uri, source.replace(CURSOR, ''), 1);
+      const document = documentManager.get(uri)?.textDocument!;
+
+      const indexOfCursor = source.indexOf(CURSOR);
+      const params: DocumentOnTypeFormattingParams = {
+        textDocument: { uri },
+        position: document.positionAt(indexOfCursor),
+        ch: '>',
+        options,
+      };
+
+      assert(document);
+
+      const result = await onTypeFormattingProvider.onTypeFormatting(params);
+      assert(!result);
+    }
+  });
+});

package/src/formatting/providers/HtmlElementAutoclosingOnTypeFormattingProvider.ts

@@ -0,0 +1,127 @@
+import {
+  getName,
+  HtmlElement,
+  LiquidHTMLASTParsingError,
+  LiquidHtmlNode,
+  NodeTypes,
+  toLiquidHtmlAST,
+} from '@platformos/liquid-html-parser';
+import {
+  DocumentOnTypeFormattingParams,
+  Position,
+  Range,
+  TextEdit,
+} from 'vscode-languageserver-protocol';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { AugmentedLiquidSourceCode } from '../../documents';
+import { findCurrentNode } from '@platformos/platformos-check-common';
+import { BaseOnTypeFormattingProvider, SetCursorPosition } from '../types';
+
+const defer = (fn: () => void) => setTimeout(fn, 10);
+
+/**
+ * This class is responsible for closing dangling HTML elements.
+ *
+ * Say user types <script>, then we'd want `</script>` to be inserted.
+ *
+ * Thing is we want to do that only if the `</script>` isn't already present in the file.
+ * If the user goes to edit `<script>` and types `>`, we don't want to insert `</script>` again.
+ *
+ * The "trick" we use here is to only add the `</script>` part if the
+ * document.ast is an instance of LiquidHTMLASTParsingError and that the
+ * unclosed element is of the correct name.
+ *
+ * @example:
+ * ```html
+ *   <div id="main">
+ *     <div id="inner">|
+ *   </div>
+ * ```
+ * - The user just finished typing `<div id="inner">` inside the div#main.
+ * - This parses as though the div#inner is closed and div#main isn't.
+ * - That's OK.
+ * - This makes a LiquidHTMLASTParsingError with unclosed div (the div#main).
+ * - Since
+ *     - the cursor is at the end of a div, and
+ *     - the unclosed element is a div,
+ *   Then we can insert one automatically after the cursor and fix the AST.
+ *
+ * ```html
+ *  <div id="main">
+ *    <div id="inner">|</div>
+ *  </div>
+ * ```
+ */
+export class HtmlElementAutoclosingOnTypeFormattingProvider
+  implements BaseOnTypeFormattingProvider
+{
+  constructor(private setCursorPosition: SetCursorPosition) {}
+
+  onTypeFormatting(
+    document: AugmentedLiquidSourceCode,
+    params: DocumentOnTypeFormattingParams,
+  ): TextEdit[] | null {
+    const textDocument = document.textDocument;
+    const ch = params.ch;
+    // position is position of cursor so 1 ahead of char
+    const { line, character } = params.position;
+    switch (ch) {
+      // here we fix `>` with `</$unclosed>`
+      case '>': {
+        const ast = document.ast;
+        if (
+          ast instanceof LiquidHTMLASTParsingError &&
+          ast.unclosed &&
+          ast.unclosed.type === NodeTypes.HtmlElement &&
+          (ast.unclosed.blockStartPosition.end === textDocument.offsetAt(params.position) ||
+            shouldClose(ast.unclosed, nodeAtCursor(textDocument, params.position)))
+        ) {
+          defer(() => this.setCursorPosition(textDocument, params.position));
+          return [TextEdit.insert(Position.create(line, character), `</${ast.unclosed.name}>`)];
+        } else if (!(ast instanceof Error)) {
+          // Even though we accept dangling <div>s inside {% if condition %}, we prefer to auto-insert the </div>
+          const [node] = findCurrentNode(ast, textDocument.offsetAt(params.position));
+          if (isDanglingHtmlElement(node)) {
+            defer(() => this.setCursorPosition(textDocument, params.position));
+            return [TextEdit.insert(Position.create(line, character), `</${getName(node)}>`)];
+          }
+        }
+      }
+    }
+    return null;
+  }
+}
+
+function nodeAtCursor(textDocument: TextDocument, position: Position) {
+  const text = textDocument.getText(Range.create(Position.create(0, 0), position));
+  try {
+    const ast = toLiquidHtmlAST(text, {
+      allowUnclosedDocumentNode: true,
+      mode: 'tolerant',
+    });
+
+    const [node, ancestors] = findCurrentNode(ast, textDocument.offsetAt(position));
+    if (ancestors.at(-1)?.type === NodeTypes.HtmlElement) return ancestors.at(-1)!;
+    if (node.type === NodeTypes.LiquidBranch) return ancestors.at(-1)!;
+    return node;
+  } catch {
+    return null;
+  }
+}
+
+function shouldClose(unclosed: any, node: LiquidHtmlNode | null) {
+  if (node === null || !('blockStartPosition' in node)) return false;
+
+  return (
+    [NodeTypes.HtmlElement, NodeTypes.LiquidTag, NodeTypes.HtmlRawNode].includes(unclosed.type) &&
+    getName(node) === unclosed.name
+  );
+}
+
+function isDanglingHtmlElement(node: LiquidHtmlNode): node is HtmlElement {
+  return (
+    node !== null &&
+    node.type === NodeTypes.HtmlElement &&
+    node.blockEndPosition.start === node.blockEndPosition.end
+  );
+}

package/src/formatting/types.ts

@@ -0,0 +1,12 @@
+import { DocumentOnTypeFormattingParams, Position, TextEdit } from 'vscode-languageserver-protocol';
+import { AugmentedSourceCode } from '../documents';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+
+export interface BaseOnTypeFormattingProvider {
+  onTypeFormatting(
+    document: AugmentedSourceCode,
+    params: DocumentOnTypeFormattingParams,
+  ): TextEdit[] | null;
+}
+
+export type SetCursorPosition = (textDocument: TextDocument, position: Position) => Promise<void>;

package/src/hover/BaseHoverProvider.ts

@@ -0,0 +1,10 @@
+import { Hover, HoverParams } from 'vscode-languageserver';
+import { LiquidHtmlNode } from '@platformos/platformos-check-common';
+
+export interface BaseHoverProvider {
+  hover(
+    currentNode: LiquidHtmlNode,
+    ancestors: LiquidHtmlNode[],
+    params: HoverParams,
+  ): Promise<Hover | null>;
+}

package/src/hover/HoverProvider.ts

@@ -0,0 +1,86 @@
+import {
+  GetDocDefinitionForURI,
+  MetafieldDefinitionMap,
+  SourceCodeType,
+  ThemeDocset,
+} from '@platformos/platformos-check-common';
+import { Hover, HoverParams } from 'vscode-languageserver';
+import { TypeSystem } from '../TypeSystem';
+import { DocumentManager } from '../documents';
+import { GetTranslationsForURI } from '../translations';
+import { BaseHoverProvider } from './BaseHoverProvider';
+import {
+  HtmlAttributeHoverProvider,
+  HtmlTagHoverProvider,
+  LiquidFilterArgumentHoverProvider,
+  LiquidFilterHoverProvider,
+  LiquidObjectAttributeHoverProvider,
+  LiquidObjectHoverProvider,
+  LiquidTagHoverProvider,
+  TranslationHoverProvider,
+  RenderPartialHoverProvider,
+  RenderPartialParameterHoverProvider,
+} from './providers';
+import { HtmlAttributeValueHoverProvider } from './providers/HtmlAttributeValueHoverProvider';
+import { findCurrentNode } from '@platformos/platformos-check-common';
+import { GetThemeSettingsSchemaForURI } from '../settings';
+import { LiquidDocTagHoverProvider } from './providers/LiquidDocTagHoverProvider';
+import { ContentForArgumentHoverProvider } from './providers/ContentForArgumentHoverProvider';
+import { ContentForTypeHoverProvider } from './providers/ContentForTypeHoverProvider';
+import { TranslationProvider } from '@platformos/platformos-common';
+import { FindThemeRootURI } from '../../src/internal-types';
+export class HoverProvider {
+  private providers: BaseHoverProvider[] = [];
+
+  constructor(
+    readonly documentManager: DocumentManager,
+    readonly themeDocset: ThemeDocset,
+    readonly translationProvider: TranslationProvider,
+    readonly getMetafieldDefinitions: (rootUri: string) => Promise<MetafieldDefinitionMap>,
+    readonly getTranslationsForURI: GetTranslationsForURI = async () => ({}),
+    readonly getSettingsSchemaForURI: GetThemeSettingsSchemaForURI = async () => [],
+    readonly getDocDefinitionForURI: GetDocDefinitionForURI = async () => undefined,
+    readonly findThemeRootURI: FindThemeRootURI = async () => null,
+  ) {
+    const typeSystem = new TypeSystem(
+      themeDocset,
+      getSettingsSchemaForURI,
+      getMetafieldDefinitions,
+    );
+    this.providers = [
+      new ContentForArgumentHoverProvider(getDocDefinitionForURI),
+      new ContentForTypeHoverProvider(getDocDefinitionForURI),
+      new LiquidTagHoverProvider(themeDocset),
+      new LiquidFilterArgumentHoverProvider(themeDocset),
+      new LiquidFilterHoverProvider(themeDocset),
+      new LiquidObjectHoverProvider(typeSystem),
+      new LiquidObjectAttributeHoverProvider(typeSystem),
+      new HtmlTagHoverProvider(),
+      new HtmlAttributeHoverProvider(),
+      new HtmlAttributeValueHoverProvider(),
+      new TranslationHoverProvider(documentManager, translationProvider, findThemeRootURI),
+      new RenderPartialHoverProvider(getDocDefinitionForURI),
+      new RenderPartialParameterHoverProvider(getDocDefinitionForURI),
+      new LiquidDocTagHoverProvider(documentManager),
+    ];
+  }
+
+  async hover(params: HoverParams): Promise<Hover | null> {
+    const uri = params.textDocument.uri;
+    const document = this.documentManager.get(uri);
+
+    // Supports only Liquid resources
+    if (document?.type !== SourceCodeType.LiquidHtml || document.ast instanceof Error) {
+      return null;
+    }
+
+    const [currentNode, ancestors] = findCurrentNode(
+      document.ast,
+      document.textDocument.offsetAt(params.position),
+    );
+
+    const promises = this.providers.map((p) => p.hover(currentNode, ancestors, params));
+    const results = await Promise.all(promises);
+    return results.find(Boolean) ?? null;
+  }
+}

package/src/hover/index.ts

@@ -0,0 +1 @@
+export { HoverProvider } from './HoverProvider';