@platformos/platformos-language-server-common 0.0.2

package/src/hover/providers/ContentForArgumentHoverProvider.spec.ts

@@ -0,0 +1,76 @@
+import { describe, beforeEach, it, expect } from 'vitest';
+import { DocumentManager } from '../../documents';
+import { HoverProvider } from '../HoverProvider';
+import { MetafieldDefinitionMap } from '@platformos/platformos-check-common';
+import { GetDocDefinitionForURI, DocDefinition } from '@platformos/platformos-check-common';
+import { TranslationProvider } from '@platformos/platformos-common';
+import { MockFileSystem } from '@platformos/platformos-check-common/src/test';
+
+const uri = 'file:///blocks/product-card.liquid';
+
+describe('Module: ContentForArgumentHoverProvider', async () => {
+  let provider: HoverProvider;
+  let getSnippetDefinition: GetDocDefinitionForURI;
+  const mockSnippetDefinition: DocDefinition = {
+    uri,
+    liquidDoc: {
+      parameters: [
+        {
+          name: 'title',
+          description: 'The title of the product',
+          type: 'string',
+          required: true,
+          nodeType: 'param',
+        },
+      ],
+    },
+  };
+
+  describe('hover', () => {
+    beforeEach(() => {
+      provider = createProvider(async () => mockSnippetDefinition);
+    });
+
+    it('should return null if doc definition not found', async () => {
+      getSnippetDefinition = async () => undefined;
+      provider = createProvider(getSnippetDefinition);
+      await expect(provider).to.hover(
+        `{% content_for 'block', type: 'product-card', tit█le: 'value' %}`,
+        null,
+      );
+    });
+
+    it('should return null if parameter not found in doc definition', async () => {
+      await expect(provider).to.hover(
+        `{% content_for 'block', type: unknown-para█m: 'value' %}`,
+        null,
+      );
+    });
+
+    it('should return parameter info from doc definition', async () => {
+      await expect(provider).to.hover(
+        `{% content_for 'block', type: 'product-card', ti█tle: 'My Product' %}`,
+        '### `title`: string\n\nThe title of the product',
+      );
+    });
+  });
+});
+
+const createProvider = (getSnippetDefinition: GetDocDefinitionForURI) => {
+  return new HoverProvider(
+    new DocumentManager(),
+    {
+      graphQL: async () => null,
+      filters: async () => [],
+      objects: async () => [],
+      liquidDrops: async () => [],
+      tags: async () => [],
+      systemTranslations: async () => ({}),
+    },
+    new TranslationProvider(new MockFileSystem({})),
+    async (_rootUri: string) => ({} as MetafieldDefinitionMap),
+    async () => ({}),
+    async () => [],
+    getSnippetDefinition,
+  );
+};

package/src/hover/providers/ContentForArgumentHoverProvider.ts

@@ -0,0 +1,56 @@
+import { NodeTypes } from '@platformos/liquid-html-parser';
+import {
+  LiquidHtmlNode,
+  GetDocDefinitionForURI,
+  getBlockName,
+} from '@platformos/platformos-check-common';
+import { Hover, HoverParams } from 'vscode-languageserver';
+import { BaseHoverProvider } from '../BaseHoverProvider';
+import { formatLiquidDocParameter } from '../../utils/liquidDoc';
+
+export class ContentForArgumentHoverProvider implements BaseHoverProvider {
+  constructor(private getDocDefinitionForURI: GetDocDefinitionForURI) {}
+
+  async hover(
+    currentNode: LiquidHtmlNode,
+    ancestors: LiquidHtmlNode[],
+    params: HoverParams,
+  ): Promise<Hover | null> {
+    const parentNode = ancestors.at(-1);
+    if (
+      currentNode.type !== NodeTypes.NamedArgument ||
+      !parentNode ||
+      parentNode.type !== NodeTypes.ContentForMarkup ||
+      parentNode.contentForType.type !== NodeTypes.String
+    ) {
+      return null;
+    }
+
+    const blockName = getBlockName(parentNode);
+
+    if (!blockName) {
+      return null;
+    }
+
+    const docDefinition = await this.getDocDefinitionForURI(
+      params.textDocument.uri,
+      'blocks',
+      blockName,
+    );
+
+    const hoverArgument = docDefinition?.liquidDoc?.parameters?.find(
+      (argument) => argument.name === currentNode.name,
+    );
+
+    if (!hoverArgument) {
+      return null;
+    }
+
+    return {
+      contents: {
+        kind: 'markdown',
+        value: formatLiquidDocParameter(hoverArgument, true),
+      },
+    };
+  }
+}

package/src/hover/providers/ContentForTypeHoverProvider.spec.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect } from 'vitest';
+import { DocumentManager } from '../../documents';
+import { HoverProvider } from '../HoverProvider';
+import { MetafieldDefinitionMap } from '@platformos/platformos-check-common';
+import { GetDocDefinitionForURI, DocDefinition } from '@platformos/platformos-check-common';
+import { TranslationProvider } from '@platformos/platformos-common';
+import { MockFileSystem } from '@platformos/platformos-check-common/src/test';
+
+const uri = 'file:///blocks/product-card.liquid';
+
+describe('Module: ContentForTypeHoverProvider', async () => {
+  let provider: HoverProvider;
+  const mockSnippetDefinition: DocDefinition = {
+    uri,
+    liquidDoc: {
+      parameters: [
+        {
+          name: 'title',
+          description: 'The title of the product',
+          type: 'string',
+          required: true,
+          nodeType: 'param',
+        },
+      ],
+      description: {
+        content: 'This is a description',
+        nodeType: 'description',
+      },
+      examples: [
+        {
+          content: '{{ product }}',
+          nodeType: 'example',
+        },
+      ],
+    },
+  };
+
+  describe('hover', () => {
+    it('should return snippet definition with all parameters', async () => {
+      provider = createProvider(async () => mockSnippetDefinition);
+      // prettier-ignore
+      const expectedHoverContent = 
+`### product-card
+
+**Description:**
+
+
+This is a description
+
+**Parameters:**
+- \`title\`: string - The title of the product
+
+**Examples:**
+\`\`\`liquid
+{{ product }}
+\`\`\``;
+
+      await expect(provider).to.hover(
+        `{% content_for 'block', type: 'product-car█d' %}`,
+        expectedHoverContent,
+      );
+    });
+
+    it("should return nothing if not in content_for tag's type argument's value", async () => {
+      await expect(provider).to.hover(
+        `{% content_for 'block', type: 'product-card', id: 'some-█string' %}`,
+        null,
+      );
+      await expect(provider).to.hover(`{{ content_for 'bl█ock', type: 'product-card' }}`, null);
+    });
+  });
+});
+
+const createProvider = (getSnippetDefinition: GetDocDefinitionForURI) => {
+  return new HoverProvider(
+    new DocumentManager(),
+    {
+      graphQL: async () => null,
+      filters: async () => [],
+      objects: async () => [],
+      liquidDrops: async () => [],
+      tags: async () => [],
+      systemTranslations: async () => ({}),
+    },
+    new TranslationProvider(new MockFileSystem({})),
+    async (_rootUri: string) => ({} as MetafieldDefinitionMap),
+    async () => ({}),
+    async () => [],
+    getSnippetDefinition,
+  );
+};

package/src/hover/providers/ContentForTypeHoverProvider.ts

@@ -0,0 +1,42 @@
+import { NodeTypes } from '@platformos/liquid-html-parser';
+import { LiquidHtmlNode, GetDocDefinitionForURI } from '@platformos/platformos-check-common';
+import { Hover, HoverParams } from 'vscode-languageserver';
+import { BaseHoverProvider } from '../BaseHoverProvider';
+import { formatLiquidDocContentMarkdown } from '../../utils/liquidDoc';
+
+export class ContentForTypeHoverProvider implements BaseHoverProvider {
+  constructor(private getDocDefinitionForURI: GetDocDefinitionForURI) {}
+
+  async hover(
+    currentNode: LiquidHtmlNode,
+    ancestors: LiquidHtmlNode[],
+    params: HoverParams,
+  ): Promise<Hover | null> {
+    const parentNode = ancestors.at(-1);
+    const grandParentNode = ancestors.at(-2);
+    if (
+      currentNode.type !== NodeTypes.String ||
+      !parentNode ||
+      !grandParentNode ||
+      parentNode.type !== NodeTypes.NamedArgument ||
+      parentNode.name !== 'type' ||
+      grandParentNode.type !== NodeTypes.ContentForMarkup
+    ) {
+      return null;
+    }
+
+    const blockName = currentNode.value;
+    const docDefinition = await this.getDocDefinitionForURI(
+      params.textDocument.uri,
+      'blocks',
+      blockName,
+    );
+
+    return {
+      contents: {
+        kind: 'markdown',
+        value: formatLiquidDocContentMarkdown(blockName, docDefinition),
+      },
+    };
+  }
+}

package/src/hover/providers/HtmlAttributeHoverProvider.spec.ts

@@ -0,0 +1,50 @@
+import { describe, beforeEach, it, expect } from 'vitest';
+import { DocumentManager } from '../../documents';
+import { HoverProvider } from '../HoverProvider';
+import { MetafieldDefinitionMap } from '@platformos/platformos-check-common';
+import { TranslationProvider } from '@platformos/platformos-common';
+import { MockFileSystem } from '@platformos/platformos-check-common/src/test';
+
+describe('Module: HtmlAttributeHoverProvider', async () => {
+  let provider: HoverProvider;
+
+  beforeEach(async () => {
+    provider = new HoverProvider(
+      new DocumentManager(),
+      {
+        graphQL: async () => null,
+        filters: async () => [],
+        objects: async () => [],
+        liquidDrops: async () => [],
+        tags: async () => [],
+        systemTranslations: async () => ({}),
+      },
+      new TranslationProvider(new MockFileSystem({}, '.')),
+      async (_rootUri: string) => ({} as MetafieldDefinitionMap),
+    );
+  });
+
+  it('should return the hover description of the attribute', async () => {
+    await expect(provider).to.hover(`<a hr█ef="..."></a>`, expect.stringMatching(/##* href/));
+    await expect(provider).to.hover(`<a href█="..."></a>`, expect.stringMatching(/##* href/));
+    await expect(provider).to.hover(`<img src█="...">`, expect.stringMatching(/##* src/));
+    await expect(provider).to.hover(`<img src█='...'>`, expect.stringMatching(/##* src/));
+    await expect(provider).to.hover(`<img src█=...>`, expect.stringMatching(/##* src/));
+    await expect(provider).to.hover(`<img src█>`, expect.stringMatching(/##* src/));
+  });
+
+  it('should return the hover description inside if statements', async () => {
+    await expect(provider).to.hover(
+      `{% if cond %}<a hr█ef="..."></a>{% endif %}`,
+      expect.stringMatching(/##* href/),
+    );
+    await expect(provider).to.hover(
+      `{% if cond %}{% else %}<a hr█ef="..."></a>{% endif %}`,
+      expect.stringMatching(/##* href/),
+    );
+  });
+
+  it('should return nothing if the thing is unknown', async () => {
+    await expect(provider).to.hover(`<a unkn█own></a>`, null);
+  });
+});

package/src/hover/providers/HtmlAttributeHoverProvider.ts

@@ -0,0 +1,48 @@
+import { Hover } from 'vscode-languageserver';
+import { BaseHoverProvider } from '../BaseHoverProvider';
+import { HtmlData, renderHtmlEntry } from '../../docset';
+import {
+  findLast,
+  getCompoundName,
+  isHtmlAttribute,
+  isNamedHtmlElementNode,
+  isTextNode,
+} from '../../utils';
+import { LiquidHtmlNode } from '@platformos/liquid-html-parser';
+
+export class HtmlAttributeHoverProvider implements BaseHoverProvider {
+  async hover(currentNode: LiquidHtmlNode, ancestors: LiquidHtmlNode[]): Promise<Hover | null> {
+    const attributeNode = ancestors.at(-1);
+    const tagNode = findLast(ancestors, isNamedHtmlElementNode);
+    if (
+      !attributeNode ||
+      !tagNode ||
+      !isTextNode(currentNode) ||
+      !isHtmlAttribute(attributeNode) ||
+      !attributeNode.name.includes(currentNode) ||
+      attributeNode.name.length > 1 ||
+      !isNamedHtmlElementNode(tagNode)
+    ) {
+      return null;
+    }
+
+    const name = currentNode.value;
+    const tagName = getCompoundName(tagNode);
+    const tagEntry = HtmlData.tags.find((tag) => tag.name === tagName);
+    const tagEntryAttributes = tagEntry?.attributes || [];
+    const attribute =
+      HtmlData.globalAttributes.find((attr) => attr.name === name) ??
+      tagEntryAttributes.find((attr) => attr.name === name);
+
+    if (!attribute) {
+      return null;
+    }
+
+    return {
+      contents: {
+        kind: 'markdown',
+        value: renderHtmlEntry(attribute, 'references' in attribute ? undefined : tagEntry),
+      },
+    };
+  }
+}

package/src/hover/providers/HtmlAttributeValueHoverProvider.spec.ts

@@ -0,0 +1,38 @@
+import { describe, beforeEach, it, expect } from 'vitest';
+import { DocumentManager } from '../../documents';
+import { HoverProvider } from '../HoverProvider';
+import { MetafieldDefinitionMap } from '@platformos/platformos-check-common';
+import { TranslationProvider } from '@platformos/platformos-common';
+import { MockFileSystem } from '@platformos/platformos-check-common/src/test';
+
+describe('Module: HtmlAttributeHoverProvider', async () => {
+  let provider: HoverProvider;
+
+  beforeEach(async () => {
+    provider = new HoverProvider(
+      new DocumentManager(),
+      {
+        graphQL: async () => null,
+        filters: async () => [],
+        objects: async () => [],
+        liquidDrops: async () => [],
+        tags: async () => [],
+        systemTranslations: async () => ({}),
+      },
+      new TranslationProvider(new MockFileSystem({}, '.')),
+      async (_rootUri: string) => ({} as MetafieldDefinitionMap),
+    );
+  });
+
+  it('should return the hover description of the attribute', async () => {
+    await expect(provider).to.hover(`<img loading="lazy█">`, expect.stringMatching(/##* lazy/));
+    await expect(provider).to.hover(`<img loading='lazy█'>`, expect.stringMatching(/##* lazy/));
+    await expect(provider).to.hover(`<img loading=lazy█>`, expect.stringMatching(/##* lazy/));
+  });
+
+  it('should return nothing if the thing is unknown', async () => {
+    await expect(provider).to.hover(`<img loading="unknown█">`, null);
+    await expect(provider).to.hover(`<img loading='unknown█'>`, null);
+    await expect(provider).to.hover(`<img loading=unknown█>`, null);
+  });
+});

package/src/hover/providers/HtmlAttributeValueHoverProvider.ts

@@ -0,0 +1,52 @@
+import { NodeTypes } from '@platformos/liquid-html-parser';
+import { LiquidHtmlNode } from '@platformos/platformos-check-common';
+import { Hover } from 'vscode-languageserver';
+import { HtmlData, renderHtmlEntry } from '../../docset';
+import {
+  findLast,
+  getCompoundName,
+  isHtmlAttribute,
+  isNamedHtmlElementNode,
+  isTextNode,
+} from '../../utils';
+import { BaseHoverProvider } from '../BaseHoverProvider';
+
+export class HtmlAttributeValueHoverProvider implements BaseHoverProvider {
+  async hover(currentNode: LiquidHtmlNode, ancestors: LiquidHtmlNode[]): Promise<Hover | null> {
+    const attributeNode = findLast(ancestors, isHtmlAttribute);
+    const tagNode = findLast(ancestors, isNamedHtmlElementNode);
+    if (
+      !isTextNode(currentNode) ||
+      !attributeNode ||
+      !tagNode ||
+      !isHtmlAttribute(attributeNode) ||
+      !isNamedHtmlElementNode(tagNode) ||
+      attributeNode.type === NodeTypes.AttrEmpty ||
+      attributeNode.value.length !== 1 ||
+      !attributeNode.value.includes(currentNode)
+    ) {
+      return null;
+    }
+
+    const valueName = currentNode.value;
+    const attrName = getCompoundName(attributeNode);
+    const tagName = getCompoundName(tagNode);
+    const tagEntry = HtmlData.tags.find((tag) => tag.name === tagName);
+    const attribute =
+      HtmlData.globalAttributes.find((attr) => attr.name === attrName) ??
+      tagEntry?.attributes.find((attr) => attr.name === attrName);
+    const valueSetName = attribute?.valueSet;
+    const valueSetEntry = HtmlData.valueSets.find((valueSet) => valueSet.name === valueSetName);
+    const valueEntry = valueSetEntry?.values.find((value) => value.name === valueName);
+    if (!valueEntry) {
+      return null;
+    }
+
+    return {
+      contents: {
+        kind: 'markdown',
+        value: renderHtmlEntry(valueEntry, attribute?.references ? attribute : tagEntry),
+      },
+    };
+  }
+}

package/src/hover/providers/HtmlTagHoverProvider.spec.ts

@@ -0,0 +1,39 @@
+import { describe, beforeEach, it, expect } from 'vitest';
+import { DocumentManager } from '../../documents';
+import { HoverProvider } from '../HoverProvider';
+import { MetafieldDefinitionMap } from '@platformos/platformos-check-common';
+import { TranslationProvider } from '@platformos/platformos-common';
+import { MockFileSystem } from '@platformos/platformos-check-common/src/test';
+
+describe('Module: HtmlTagHoverProvider', async () => {
+  let provider: HoverProvider;
+
+  beforeEach(async () => {
+    provider = new HoverProvider(
+      new DocumentManager(),
+      {
+        graphQL: async () => null,
+        filters: async () => [],
+        objects: async () => [],
+        liquidDrops: async () => [],
+        tags: async () => [],
+        systemTranslations: async () => ({}),
+      },
+      new TranslationProvider(new MockFileSystem({})),
+      async (_rootUri: string) => ({} as MetafieldDefinitionMap),
+    );
+  });
+
+  it('should return the hover description of the tag', async () => {
+    await expect(provider).to.hover(`<a█ href="..."></a>`, expect.stringMatching(/##* a/));
+    await expect(provider).to.hover(`<img█ src="...">`, expect.stringMatching(/##* img/));
+    await expect(provider).to.hover(`<img█ src="..."/>`, expect.stringMatching(/##* img/));
+    await expect(provider).to.hover(`<i█mg src="...">`, expect.stringMatching(/##* img/));
+    await expect(provider).to.hover(`<img src="..." █>`, expect.stringMatching(/##* img/));
+  });
+
+  it('should return nothing if the thing is unknown', async () => {
+    await expect(provider).to.hover(`<unknown█ ></unknown>`, null);
+    await expect(provider).to.hover(`<unknown█ />`, null);
+  });
+});

package/src/hover/providers/HtmlTagHoverProvider.ts

@@ -0,0 +1,42 @@
+import { LiquidHtmlNode } from '@platformos/platformos-check-common';
+import { Hover } from 'vscode-languageserver';
+import { HtmlData, renderHtmlEntry } from '../../docset';
+import { isNamedHtmlElementNode, isTextNode } from '../../utils';
+import { BaseHoverProvider } from '../BaseHoverProvider';
+
+export class HtmlTagHoverProvider implements BaseHoverProvider {
+  async hover(currentNode: LiquidHtmlNode, ancestors: LiquidHtmlNode[]): Promise<Hover | null> {
+    let name: string | undefined;
+    const parentNode = ancestors.at(-1);
+
+    if (isNamedHtmlElementNode(currentNode) && typeof currentNode.name === 'string') {
+      name = currentNode.name;
+    } else if (
+      isTextNode(currentNode) &&
+      parentNode &&
+      isNamedHtmlElementNode(parentNode) &&
+      typeof parentNode.name !== 'string' &&
+      parentNode.name.includes(currentNode) &&
+      parentNode.name.length === 1
+    ) {
+      name = currentNode.value;
+    }
+
+    if (!name) {
+      return null;
+    }
+
+    const entry = HtmlData.tags.find((tag) => tag.name === name);
+
+    if (!entry) {
+      return null;
+    }
+
+    return {
+      contents: {
+        kind: 'markdown',
+        value: renderHtmlEntry(entry),
+      },
+    };
+  }
+}

package/src/hover/providers/LiquidDocTagHoverProvider.spec.ts

@@ -0,0 +1,64 @@
+import { describe, beforeEach, it, expect } from 'vitest';
+import { DocumentManager } from '../../documents';
+import { HoverProvider } from '../HoverProvider';
+import { MetafieldDefinitionMap } from '@platformos/platformos-check-common';
+import '../../../../platformos-check-common/src/test/test-setup';
+import { formatLiquidDocTagHandle, SUPPORTED_LIQUID_DOC_TAG_HANDLES } from '../../utils/liquidDoc';
+import { TranslationProvider } from '@platformos/platformos-common';
+import { MockFileSystem } from '@platformos/platformos-check-common/src/test';
+
+describe('Module: RenderSnippetParameterHoverProvider', async () => {
+  let provider: HoverProvider;
+
+  beforeEach(() => {
+    provider = new HoverProvider(
+      new DocumentManager(),
+      {
+        graphQL: async () => null,
+        filters: async () => [],
+        objects: async () => [],
+        liquidDrops: async () => [],
+        tags: async () => [],
+        systemTranslations: async () => ({}),
+      },
+      new TranslationProvider(new MockFileSystem({})),
+      async (_rootUri: string) => ({} as MetafieldDefinitionMap),
+    );
+  });
+
+  it('should show the param help doc when hovering over the tag itself', async () => {
+    await expect(provider).to.hover(
+      `{% doc %} @para█m {string} name - your name {% enddoc %}`,
+      formatLiquidDocTagHandle(
+        'param',
+        SUPPORTED_LIQUID_DOC_TAG_HANDLES['param'].description,
+        SUPPORTED_LIQUID_DOC_TAG_HANDLES['param'].example,
+      ),
+    );
+    await expect(provider).to.hover(
+      `{% doc %} @exampl█e my example {% enddoc %}`,
+      formatLiquidDocTagHandle(
+        'example',
+        SUPPORTED_LIQUID_DOC_TAG_HANDLES['example'].description,
+        SUPPORTED_LIQUID_DOC_TAG_HANDLES['example'].example,
+      ),
+    );
+    await expect(provider).to.hover(
+      `{% doc %} @descrip█tion cool text is cool {% enddoc %}`,
+      formatLiquidDocTagHandle(
+        'description',
+        SUPPORTED_LIQUID_DOC_TAG_HANDLES['description'].description,
+        SUPPORTED_LIQUID_DOC_TAG_HANDLES['description'].example,
+      ),
+    );
+  });
+
+  it('should not show the param help doc when hovering over text outside param name', async () => {
+    await expect(provider).to.hover(
+      `{% doc %} @param {string} name - █your name {% enddoc %}`,
+      null,
+    );
+    await expect(provider).to.hover(`{% doc %} @example my █example {% enddoc %}`, null);
+    await expect(provider).to.hover(`{% doc %} @description cool text█ is cool {% enddoc %}`, null);
+  });
+});

package/src/hover/providers/LiquidDocTagHoverProvider.ts

@@ -0,0 +1,58 @@
+import { NodeTypes } from '@platformos/liquid-html-parser';
+import { LiquidHtmlNode } from '@platformos/platformos-check-common';
+import { Hover, HoverParams, MarkupKind } from 'vscode-languageserver';
+import { BaseHoverProvider } from '../BaseHoverProvider';
+import { formatLiquidDocTagHandle, SUPPORTED_LIQUID_DOC_TAG_HANDLES } from '../../utils/liquidDoc';
+import { DocumentManager } from '../../documents';
+
+export class LiquidDocTagHoverProvider implements BaseHoverProvider {
+  constructor(private documentManager: DocumentManager) {}
+
+  async hover(
+    currentNode: LiquidHtmlNode,
+    ancestors: LiquidHtmlNode[],
+    params: HoverParams,
+  ): Promise<Hover | null> {
+    const parentNode = ancestors.at(-1);
+
+    if (
+      currentNode.type !== NodeTypes.LiquidDocParamNode &&
+      currentNode.type !== NodeTypes.LiquidDocDescriptionNode &&
+      currentNode.type !== NodeTypes.LiquidDocExampleNode
+    ) {
+      return null;
+    }
+
+    const document = this.documentManager.get(params.textDocument.uri)?.textDocument;
+
+    // We only want to provide hover when we are on the exact tag name
+    // If the cursor is passed that but still within the tag node, we ignore it
+    //
+    // E.g.
+    // Provide hover: @para█m name - description
+    // Don't provide hover: @param █name - description
+    if (
+      document &&
+      document.offsetAt(params.position) > currentNode.position.start + currentNode.name.length
+    ) {
+      return null;
+    }
+
+    const docTagData = SUPPORTED_LIQUID_DOC_TAG_HANDLES[currentNode.name];
+
+    if (!docTagData) {
+      return null;
+    }
+
+    return {
+      contents: {
+        kind: MarkupKind.Markdown,
+        value: formatLiquidDocTagHandle(
+          currentNode.name,
+          docTagData.description,
+          docTagData.example,
+        ),
+      },
+    };
+  }
+}