@platformos/platformos-language-server-common 0.0.2

package/src/json/documentLinks/DocumentLinksProvider.ts

@@ -0,0 +1,61 @@
+import { JSONNode, SourceCodeType } from '@platformos/platformos-check-common';
+import { DocumentLink, Range } from 'vscode-languageserver';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { URI, Utils } from 'vscode-uri';
+import { Visitor } from '@platformos/platformos-check-common';
+
+export async function createJSONDocumentLinksVisitor(
+  textDocument: TextDocument,
+  root: URI,
+  offset: number = 0,
+): Promise<Visitor<SourceCodeType.JSON, DocumentLink>> {
+  const visitor: Visitor<SourceCodeType.JSON, DocumentLink> = {
+    async Property(node, ancestors) {
+      const origin = jsonPropertyOriginDirectory(ancestors);
+
+      if (!origin) return;
+
+      if (
+        !(
+          node.key.value === 'type' &&
+          node.value.type === 'Literal' &&
+          typeof node.value.value === 'string'
+        )
+      ) {
+        return;
+      }
+
+      if (origin === 'blocks' && ['@app', '@theme'].includes(node.value.value)) {
+        return;
+      }
+
+      return DocumentLink.create(
+        range(textDocument, node.value, offset),
+        Utils.resolvePath(root, origin, node.value.value + '.liquid').toString(),
+      );
+    },
+  };
+  return visitor;
+}
+
+function range(textDocument: TextDocument, node: JSONNode, offset: number): Range {
+  // +1 and -1 to exclude the quotes
+  const start = textDocument.positionAt(offset + node.loc.start.offset + 1);
+  const end = textDocument.positionAt(offset + node.loc.end.offset - 1);
+  return Range.create(start, end);
+}
+
+function jsonPropertyOriginDirectory(ancestors: JSONNode[]): 'sections' | 'blocks' | undefined {
+  for (let i = ancestors.length - 1; i >= 0; i--) {
+    const ancestor = ancestors[i];
+    if (ancestor.type === 'Property') {
+      if (ancestor.key.value === 'blocks') {
+        return 'blocks';
+      }
+      if (ancestor.key.value === 'sections') {
+        return 'sections';
+      }
+    }
+  }
+  return undefined;
+}

package/src/json/hover/JSONHoverProvider.ts

@@ -0,0 +1,8 @@
+import { JSONPath, MarkedString } from 'vscode-json-languageservice';
+import { RequestContext } from '../RequestContext';
+
+export interface JSONHoverProvider {
+  /** Must be sync because of weird JSONWorkerContribution API */
+  canHover(context: RequestContext, location: JSONPath): boolean;
+  hover(context: RequestContext, location: JSONPath): Promise<MarkedString[]>;
+}

package/src/json/hover/providers/BlockSettingsHoverProvider.spec.ts

@@ -0,0 +1,292 @@
+import { describe, beforeEach, it, expect } from 'vitest';
+import { DocumentManager } from '../../../documents';
+import { JSONLanguageService } from '../../JSONLanguageService';
+import { getRequestParams, mockJSONLanguageService } from '../../test/test-helpers';
+
+describe('Module: BlockSettingsHoverProvider', async () => {
+  const rootUri = 'file:///root';
+  let jsonLanguageService: JSONLanguageService;
+  let documentManager: DocumentManager;
+
+  beforeEach(async () => {
+    documentManager = new DocumentManager(
+      undefined, // don't need a fs
+      undefined, // don't need a connection
+      undefined, // don't need client capabilities
+      async () => 'theme', // 'theme' mode
+      async () => false, // schema is invalid for tests
+    );
+    jsonLanguageService = mockJSONLanguageService(
+      rootUri,
+      documentManager,
+      async (uri: string) => ({
+        general: {
+          fake: 'Fake Setting',
+        },
+      }),
+    );
+
+    await jsonLanguageService.setup({
+      textDocument: {
+        hover: {},
+        completion: {
+          contextSupport: true,
+          completionItem: {
+            snippetSupport: true,
+            commitCharactersSupport: true,
+            documentationFormat: ['markdown'],
+            deprecatedSupport: true,
+            preselectSupport: true,
+          },
+        },
+      },
+    });
+  });
+
+  const testBlockName = 'test-block';
+
+  describe('valid theme block settings', async () => {
+    beforeEach(() => {
+      const testBlockSchema = {
+        settings: [
+          { id: 'custom-setting', label: 'Custom Setting' },
+          { id: 'fake-setting', label: 't:general.fake' },
+        ],
+      };
+      documentManager.open(
+        `${rootUri}/blocks/${testBlockName}.liquid`,
+        toSource(testBlockSchema),
+        1,
+      );
+    });
+
+    it('provides hover when referenced block has literal settings label', async () => {
+      const testSectionSchema = {
+        presets: [
+          {
+            blocks: {
+              [testBlockName]: {
+                type: testBlockName,
+                settings: {
+                  'custom-setting█': '',
+                },
+              },
+            },
+          },
+        ],
+      };
+      const params = getRequestParams(
+        documentManager,
+        'sections/test-section.liquid',
+        toSource(testSectionSchema),
+      );
+      const hover = await jsonLanguageService.hover(params);
+      expect(hover).not.toBeNull();
+      expect(hover!.contents).to.have.lengthOf(1);
+      expect(hover!.contents).toEqual(['Custom Setting']);
+    });
+
+    it('provides hover when referenced block has translation settings label', async () => {
+      const testSectionSchema = {
+        presets: [
+          {
+            blocks: {
+              [testBlockName]: {
+                type: testBlockName,
+                settings: {
+                  'fake-setting█': '',
+                },
+              },
+            },
+          },
+        ],
+      };
+      const params = getRequestParams(
+        documentManager,
+        'sections/test-section.liquid',
+        toSource(testSectionSchema),
+      );
+      const hover = await jsonLanguageService.hover(params);
+      expect(hover).not.toBeNull();
+      expect(hover!.contents).to.have.lengthOf(1);
+      expect(hover!.contents).toEqual(['Fake Setting']);
+    });
+
+    it('provides hover when block reference is nested within another referenced block', async () => {
+      const testSectionSchema = {
+        presets: [
+          {
+            blocks: [
+              {
+                type: 'fake-block',
+                blocks: {
+                  [testBlockName]: {
+                    type: testBlockName,
+                    settings: {
+                      'fake-setting█': '',
+                    },
+                  },
+                },
+              },
+            ],
+          },
+        ],
+      };
+      const params = getRequestParams(
+        documentManager,
+        'sections/test-section.liquid',
+        toSource(testSectionSchema),
+      );
+      const hover = await jsonLanguageService.hover(params);
+      expect(hover).not.toBeNull();
+      expect(hover!.contents).to.have.lengthOf(1);
+      expect(hover!.contents).toEqual(['Fake Setting']);
+    });
+  });
+
+  describe('valid section block settings', async () => {
+    function hoverParams(settingId: string) {
+      const testSectionSchema = {
+        blocks: [
+          {
+            type: testBlockName,
+            name: 'Test Block',
+            settings: [
+              { id: 'custom-setting', label: 'Custom Setting' },
+              { id: 'fake-setting', label: 't:general.fake' },
+            ],
+          },
+        ],
+        presets: [
+          {
+            blocks: {
+              [testBlockName]: {
+                type: testBlockName,
+                settings: {
+                  [`${settingId}█`]: '',
+                },
+              },
+            },
+          },
+        ],
+      };
+      return getRequestParams(
+        documentManager,
+        'sections/test-section.liquid',
+        toSource(testSectionSchema),
+      );
+    }
+
+    it('provides hover when referenced block has literal settings label', async () => {
+      const params = hoverParams('custom-setting');
+      const hover = await jsonLanguageService.hover(params);
+      expect(hover).not.toBeNull();
+      expect(hover!.contents).to.have.lengthOf(1);
+      expect(hover!.contents).toEqual(['Custom Setting']);
+    });
+
+    it('provides hover when referenced block has translation settings label', async () => {
+      const params = hoverParams('fake-setting');
+      const hover = await jsonLanguageService.hover(params);
+      expect(hover).not.toBeNull();
+      expect(hover!.contents).to.have.lengthOf(1);
+      expect(hover!.contents).toEqual(['Fake Setting']);
+    });
+  });
+
+  describe('invalid theme block settings', async () => {
+    it('provides no hover when block file nor local block exist', async () => {
+      const testSectionSchema = {
+        presets: [
+          {
+            blocks: {
+              [testBlockName]: {
+                type: testBlockName,
+                settings: {
+                  'nonexistent-setting█': '',
+                },
+              },
+            },
+          },
+        ],
+      };
+      const params = getRequestParams(
+        documentManager,
+        'sections/test-section.liquid',
+        toSource(testSectionSchema),
+      );
+      const hover = await jsonLanguageService.hover(params);
+      expect(hover).not.toBeNull();
+      expect(hover!.contents).to.have.lengthOf(0);
+    });
+
+    it('provides no hover when block file has no settings', async () => {
+      const testBlockSchema = {};
+      documentManager.open(
+        `${rootUri}/blocks/${testBlockName}.liquid`,
+        toSource(testBlockSchema),
+        1,
+      );
+
+      const testSectionSchema = {
+        presets: [
+          {
+            blocks: {
+              [testBlockName]: {
+                type: testBlockName,
+                settings: {
+                  'nonexistent-setting█': '',
+                },
+              },
+            },
+          },
+        ],
+      };
+      const params = getRequestParams(
+        documentManager,
+        'sections/test-section.liquid',
+        toSource(testSectionSchema),
+      );
+      const hover = await jsonLanguageService.hover(params);
+      expect(hover).not.toBeNull();
+      expect(hover!.contents).to.have.lengthOf(0);
+    });
+
+    it('provides no hover when local block has no settings', async () => {
+      const testSectionSchema = {
+        blocks: [
+          {
+            type: testBlockName,
+            name: 'Test Block',
+          },
+        ],
+        presets: [
+          {
+            blocks: {
+              [testBlockName]: {
+                type: testBlockName,
+                settings: {
+                  'nonexistent-setting█': '',
+                },
+              },
+            },
+          },
+        ],
+      };
+      const params = getRequestParams(
+        documentManager,
+        'sections/test-section.liquid',
+        toSource(testSectionSchema),
+      );
+      const hover = await jsonLanguageService.hover(params);
+      expect(hover).not.toBeNull();
+      expect(hover!.contents).to.have.lengthOf(0);
+    });
+  });
+});
+
+function toSource(schema: object) {
+  return `{% schema %}
+  ${JSON.stringify(schema)}
+{% endschema %}`;
+}

package/src/json/hover/providers/BlockSettingsHoverProvider.ts

@@ -0,0 +1,99 @@
+import {
+  AppBlockSchema,
+  deepGet,
+  isError,
+  SectionSchema,
+  Setting,
+  ThemeBlockSchema,
+} from '@platformos/platformos-check-common';
+import { JSONPath, MarkedString } from 'vscode-json-languageservice';
+import { GetTranslationsForURI, renderTranslation, translationValue } from '../../../translations';
+import { isLiquidRequestContext, LiquidRequestContext, RequestContext } from '../../RequestContext';
+import { isSectionOrBlockFile } from '../../utils';
+import { JSONHoverProvider } from '../JSONHoverProvider';
+import { isSectionOrBlockSchema } from '../../completions/providers/BlockTypeCompletionProvider';
+import { GetThemeBlockSchema } from '../../JSONContributions';
+import { getSectionBlockByName } from '../../schemaSettings';
+
+export class BlockSettingsHoverProvider implements JSONHoverProvider {
+  constructor(
+    private getDefaultSchemaTranslations: GetTranslationsForURI,
+    private getThemeBlockSchema: GetThemeBlockSchema,
+  ) {}
+
+  canHover(context: RequestContext, path: JSONPath): context is LiquidRequestContext {
+    return (
+      isSectionOrBlockFile(context.doc.uri) &&
+      isLiquidRequestContext(context) &&
+      path.length !== 0 &&
+      isBlocksSettingsPath(path)
+    );
+  }
+
+  async hover(context: RequestContext, path: JSONPath): Promise<MarkedString[]> {
+    if (!this.canHover(context, path)) return [];
+
+    const { doc } = context;
+    const schema = await doc.getSchema();
+
+    if (!isValidSchema(schema)) return [];
+
+    const blockType = deepGet(schema.parsed, [...path.slice(0, -2), 'type']);
+
+    if (!blockType) return [];
+
+    const sectionBlock = getSectionBlockByName(schema.parsed, blockType);
+
+    let label: string | undefined;
+
+    if (sectionBlock) {
+      if (!hasValidSettings(sectionBlock.settings)) return [];
+
+      label = getSettingLabelById(sectionBlock.settings, path.at(-1) as string);
+    } else {
+      const themeBlockSchema = await this.getThemeBlockSchema(doc.uri, blockType);
+
+      if (!isValidSchema(themeBlockSchema)) return [];
+      if (!hasValidSettings(themeBlockSchema.parsed.settings)) return [];
+
+      label = getSettingLabelById(themeBlockSchema.parsed.settings, path.at(-1) as string);
+    }
+
+    if (!label) return [];
+
+    if (!label.startsWith('t:')) {
+      return [label];
+    }
+
+    const translations = await this.getDefaultSchemaTranslations(doc.uri);
+
+    const value = translationValue(label.substring(2), translations);
+    if (!value) return [];
+
+    return [renderTranslation(value)];
+  }
+}
+
+function isBlocksSettingsPath(path: JSONPath) {
+  return (
+    (path.at(0) === 'presets' || path.at(0) === 'default') &&
+    path.at(-4) === 'blocks' &&
+    path.at(-2) === 'settings' &&
+    path.at(-1) !== undefined &&
+    typeof path.at(-1) === 'string'
+  );
+}
+
+function isValidSchema(
+  schema: SectionSchema | ThemeBlockSchema | AppBlockSchema | undefined,
+): schema is SectionSchema | ThemeBlockSchema {
+  return !!schema && !isError(schema.parsed) && isSectionOrBlockSchema(schema);
+}
+
+function hasValidSettings(settings: any): settings is Partial<Setting.Any>[] {
+  return settings !== undefined && Array.isArray(settings);
+}
+
+function getSettingLabelById(settings: Partial<Setting.Any>[], id: string) {
+  return settings.find((setting) => setting.id === id)?.label;
+}

package/src/json/hover/providers/SchemaTranslationHoverProvider.ts

@@ -0,0 +1,35 @@
+import { deepGet } from '@platformos/platformos-check-common';
+import { JSONPath, MarkedString } from 'vscode-json-languageservice';
+import { GetTranslationsForURI, renderTranslation, translationValue } from '../../../translations';
+import { isLiquidRequestContext, LiquidRequestContext, RequestContext } from '../../RequestContext';
+import { isSectionOrBlockFile } from '../../utils';
+import { JSONHoverProvider } from '../JSONHoverProvider';
+
+export class SchemaTranslationHoverProvider implements JSONHoverProvider {
+  constructor(private getDefaultSchemaTranslations: GetTranslationsForURI) {}
+
+  canHover(context: RequestContext, path: JSONPath): context is LiquidRequestContext {
+    const label = deepGet(context.parsed, path);
+    return (
+      isSectionOrBlockFile(context.doc.uri) &&
+      isLiquidRequestContext(context) &&
+      path.length !== 0 &&
+      label &&
+      typeof label === 'string' &&
+      label.startsWith('t:')
+    );
+  }
+
+  async hover(context: RequestContext, path: JSONPath): Promise<MarkedString[]> {
+    if (!this.canHover(context, path)) return [];
+    // Can assert is a string because of `canHover` check above
+    const label = deepGet(context.parsed, path) as string;
+    return this.getDefaultSchemaTranslations(context.doc.uri).then((translations) => {
+      const path = label.slice(2); // remove `t:`
+      const value = translationValue(path, translations);
+      if (!value) return undefined as any;
+
+      return [renderTranslation(value)];
+    });
+  }
+}

package/src/json/hover/providers/SettingsHoverProvider.spec.ts

@@ -0,0 +1,139 @@
+import { describe, beforeEach, it, expect } from 'vitest';
+import { DocumentManager } from '../../../documents';
+import { JSONLanguageService } from '../../JSONLanguageService';
+import { getRequestParams, mockJSONLanguageService } from '../../test/test-helpers';
+
+describe('Module: SettingsHoverProvider', async () => {
+  const rootUri = 'file:///root/';
+  let jsonLanguageService: JSONLanguageService;
+  let documentManager: DocumentManager;
+
+  beforeEach(async () => {
+    documentManager = new DocumentManager(
+      undefined, // don't need a fs
+      undefined, // don't need a connection
+      undefined, // don't need client capabilities
+      async () => 'theme', // 'theme' mode
+      async () => false, // schema is invalid for tests
+    );
+    jsonLanguageService = mockJSONLanguageService(
+      rootUri,
+      documentManager,
+      async (uri: string) => ({
+        general: {
+          fake: 'Fake Setting',
+        },
+      }),
+    );
+
+    await jsonLanguageService.setup({
+      textDocument: {
+        hover: {},
+        completion: {
+          contextSupport: true,
+          completionItem: {
+            snippetSupport: true,
+            commitCharactersSupport: true,
+            documentationFormat: ['markdown'],
+            deprecatedSupport: true,
+            preselectSupport: true,
+          },
+        },
+      },
+    });
+  });
+
+  const tests = [
+    {
+      label: 'preset',
+      schemaTemplate: (setting: object) => {
+        return {
+          presets: [setting],
+        };
+      },
+    },
+    {
+      label: 'default',
+      schemaTemplate: (setting: object) => {
+        return {
+          default: setting,
+        };
+      },
+    },
+  ];
+
+  for (const test of tests) {
+    describe(`${test.label} settings`, () => {
+      it(`provide hover for ${test.label} setting when setting label contains a translation key`, async () => {
+        const schema = {
+          settings: [
+            { id: 'custom-setting', label: 'Custom Setting' },
+            { id: 'fake-setting', label: 't:general.fake' },
+          ],
+          ...test.schemaTemplate({
+            settings: {
+              'fake-setting█': '',
+            },
+          }),
+        };
+        const source = `
+          {% schema %}
+            ${JSON.stringify(schema)}
+          {% endschema %}
+        `;
+        const params = getRequestParams(documentManager, 'blocks/block.liquid', source);
+        const hover = await jsonLanguageService.hover(params);
+
+        expect(hover).not.toBeNull();
+        expect(hover!.contents).to.have.lengthOf(1);
+        expect(hover!.contents).toEqual(['Fake Setting']);
+      });
+
+      it(`provide hover for ${test.label} setting when setting label is literal text`, async () => {
+        const schema = {
+          settings: [
+            { id: 'custom-setting', label: 'Custom Setting' },
+            { id: 'fake-setting', label: 't:general.fake' },
+          ],
+          ...test.schemaTemplate({
+            settings: {
+              'custom-setting█': '',
+            },
+          }),
+        };
+        const source = `
+          {% schema %}
+            ${JSON.stringify(schema)}
+          {% endschema %}
+        `;
+        const params = getRequestParams(documentManager, 'blocks/block.liquid', source);
+        const hover = await jsonLanguageService.hover(params);
+
+        expect(hover).not.toBeNull();
+        expect(hover!.contents).to.have.lengthOf(1);
+        expect(hover!.contents).toEqual(['Custom Setting']);
+      });
+
+      it(`provide no hover for ${test.label} setting when setting label does not exist`, async () => {
+        const schema = {
+          settings: [{ id: 'custom-setting' }, { id: 'fake-setting', label: 't:general.fake' }],
+          ...test.schemaTemplate({
+            settings: {
+              'custom-setting█': '',
+            },
+          }),
+        };
+        const source = `
+          {% schema %}
+            ${JSON.stringify(schema)}
+          {% endschema %}
+        `;
+        const params = getRequestParams(documentManager, 'blocks/block.liquid', source);
+        const hover = await jsonLanguageService.hover(params);
+
+        expect(hover).not.toBeNull();
+        expect(hover!.contents).to.have.lengthOf(0);
+      });
+    });
+  }
+});