@platformos/platformos-language-server-common 0.0.2

package/src/definitions/providers/SchemaTranslationStringDefinitionProvider.spec.ts

@@ -0,0 +1,96 @@
+import { JSONSourceCode, SourceCodeType, toSourceCode } from '@platformos/platformos-check-common';
+import { assert, beforeEach, describe, expect, it } from 'vitest';
+import { DefinitionParams, LocationLink } from 'vscode-languageserver-protocol';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { AugmentedJsonSourceCode, DocumentManager } from '../../documents';
+import { DefinitionProvider } from '../DefinitionProvider';
+
+describe('Module: SchemaTranslationStringDefinitionProvider', () => {
+  let provider: DefinitionProvider;
+  let documentManager: DocumentManager;
+  let mockGetDefaultSchemaLocaleSourceCode: (uri: string) => Promise<any>;
+
+  beforeEach(() => {
+    documentManager = new DocumentManager(
+      undefined,
+      undefined,
+      undefined,
+      async () => 'theme',
+      async () => true,
+    );
+
+    const translationFileContents = JSON.stringify(
+      {
+        hello: {
+          world: 'Hello World',
+        },
+      },
+      null,
+      2,
+    );
+
+    const uri = 'file:///locales/en.default.schema.json';
+    const sourceCode = toSourceCode(uri, translationFileContents) as JSONSourceCode;
+    const textDocument = TextDocument.create(uri, sourceCode.type, 1, sourceCode.source);
+    mockGetDefaultSchemaLocaleSourceCode = async (): Promise<AugmentedJsonSourceCode> => {
+      return {
+        ...sourceCode,
+        textDocument,
+      };
+    };
+
+    provider = new DefinitionProvider(
+      documentManager,
+      async () => null,
+      mockGetDefaultSchemaLocaleSourceCode,
+    );
+  });
+
+  it('finds the definition of existing translation keys', async () => {
+    const source = `
+      {% schema %}
+        {
+          "name": "t:hello.world"
+        }
+      {% endschema %}
+    `;
+    documentManager.open('file:///blocks/test.liquid', source, 1);
+    const params: DefinitionParams = {
+      textDocument: { uri: 'file:///blocks/test.liquid' },
+      position: { line: 3, character: 26 }, // Position within "t:hello.world"
+    };
+
+    const result = await provider.definitions(params);
+
+    assert(result);
+    expect(result).toHaveLength(1);
+    assert(LocationLink.is(result[0]));
+    expect(result[0]).toMatchObject({
+      targetUri: 'file:///locales/en.default.schema.json',
+      targetRange: {
+        start: { line: 2, character: expect.any(Number) },
+        end: { line: 2, character: expect.any(Number) },
+      },
+    });
+  });
+
+  it('returns null for non-existent translation key', async () => {
+    const source = `
+      {% schema %}
+        {
+          "name": "t:hello.world"
+        }
+      {% endschema %}
+    `;
+    documentManager.open('file:///blocks/products.liquid', source, 1);
+
+    const params: DefinitionParams = {
+      textDocument: { uri: 'file:///blocks/products.liquid' },
+      position: { line: 0, character: 7 }, // Position within "unknown.key"
+    };
+
+    const result = await provider.definitions(params);
+
+    assert(result === null);
+  });
+});

package/src/definitions/providers/SchemaTranslationStringDefinitionProvider.ts

@@ -0,0 +1,82 @@
+import { LiquidHtmlNode, LiquidRawTag, NodeTypes } from '@platformos/liquid-html-parser';
+import { SourceCodeType, findJSONNode, nodeAtPath } from '@platformos/platformos-check-common';
+import {
+  DefinitionLink,
+  DefinitionParams,
+  LocationLink,
+  Range,
+} from 'vscode-languageserver-protocol';
+import { AugmentedJsonSourceCode, DocumentManager } from '../../documents';
+import { BaseDefinitionProvider } from '../BaseDefinitionProvider';
+
+export class SchemaTranslationStringDefinitionProvider implements BaseDefinitionProvider {
+  constructor(
+    private documentManager: DocumentManager,
+    private getDefaultSchemaLocaleSourceCode: (
+      uri: string,
+    ) => Promise<AugmentedJsonSourceCode | null>,
+  ) {}
+
+  async definitions(
+    params: DefinitionParams,
+    node: LiquidHtmlNode,
+    ancestors: LiquidHtmlNode[],
+  ): Promise<DefinitionLink[]> {
+    const sourceCode = this.documentManager.get(params.textDocument.uri);
+    if (!sourceCode || sourceCode.type !== SourceCodeType.LiquidHtml) return [];
+
+    // We want text inside {% schema %}
+    if (node.type !== NodeTypes.TextNode) return [];
+    const schemaTag = ancestors.find(isSchemaTag);
+    if (!schemaTag) {
+      return [];
+    }
+
+    const schema = await sourceCode.getSchema();
+    if (!schema || schema.ast instanceof Error) return [];
+
+    // Now we need to find the location of the translation in the translation file
+    const defaultLocaleFile = await this.getDefaultSchemaLocaleSourceCode(params.textDocument.uri);
+    if (
+      !defaultLocaleFile ||
+      defaultLocaleFile.type !== SourceCodeType.JSON ||
+      defaultLocaleFile.ast instanceof Error
+    ) {
+      return [];
+    }
+
+    const documentOffset = sourceCode.textDocument.offsetAt(params.position);
+    const offset = documentOffset - schema.offset;
+    const [jNode, _jAncestors] = findJSONNode(schema.ast, offset);
+
+    if (jNode.type !== 'Literal') return [];
+    if (typeof jNode.value !== 'string' || !jNode.value.startsWith('t:')) return [];
+
+    const translationKey = jNode.value.slice(2).trim();
+    const translationNode = nodeAtPath(defaultLocaleFile.ast, translationKey.split('.'));
+
+    if (!translationNode) return [];
+
+    const targetRange = Range.create(
+      defaultLocaleFile.textDocument.positionAt(translationNode.loc.start.offset),
+      defaultLocaleFile.textDocument.positionAt(translationNode.loc.end.offset),
+    );
+    const originRange = Range.create(
+      sourceCode.textDocument.positionAt(schema.offset + jNode.loc.start.offset),
+      sourceCode.textDocument.positionAt(schema.offset + jNode.loc.end.offset),
+    );
+
+    return [
+      LocationLink.create(
+        defaultLocaleFile.textDocument.uri,
+        targetRange,
+        targetRange,
+        originRange,
+      ),
+    ];
+  }
+}
+
+function isSchemaTag(node: LiquidHtmlNode): node is LiquidRawTag & { name: 'schema' } {
+  return node.type === NodeTypes.LiquidRawTag && node.name === 'schema';
+}

package/src/definitions/providers/TranslationStringDefinitionProvider.spec.ts

@@ -0,0 +1,77 @@
+import { JSONSourceCode, SourceCodeType, toSourceCode } from '@platformos/platformos-check-common';
+import { assert, beforeEach, describe, expect, it } from 'vitest';
+import { DefinitionParams, LocationLink } from 'vscode-languageserver-protocol';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { AugmentedJsonSourceCode, DocumentManager } from '../../documents';
+import { DefinitionProvider } from '../DefinitionProvider';
+
+describe('Module: TranslationStringDefinitionProvider', () => {
+  let provider: DefinitionProvider;
+  let documentManager: DocumentManager;
+  let mockGetDefaultLocaleSourceCode: (uri: string) => Promise<any>;
+
+  beforeEach(() => {
+    documentManager = new DocumentManager();
+
+    const translationFileContents = JSON.stringify(
+      {
+        hello: {
+          world: 'Hello World',
+        },
+      },
+      null,
+      2,
+    );
+
+    const uri = 'file:///locales/en.default.json';
+    const sourceCode = toSourceCode(uri, translationFileContents) as JSONSourceCode;
+    const textDocument = TextDocument.create(uri, sourceCode.type, 1, sourceCode.source);
+    mockGetDefaultLocaleSourceCode = async (_uri: string): Promise<AugmentedJsonSourceCode> => {
+      return {
+        ...sourceCode,
+        textDocument,
+      };
+    };
+
+    provider = new DefinitionProvider(
+      documentManager,
+      mockGetDefaultLocaleSourceCode,
+      async () => null,
+    );
+  });
+
+  it('finds the definition of existing translation keys', async () => {
+    documentManager.open('file:///test.liquid', '{{ "hello.world" | t }}', 1);
+    const params: DefinitionParams = {
+      textDocument: { uri: 'file:///test.liquid' },
+      position: { line: 0, character: 5 }, // Position within "hello.world"
+    };
+
+    const result = await provider.definitions(params);
+
+    assert(result);
+    expect(result).toHaveLength(1);
+    assert(LocationLink.is(result[0]));
+    expect(result[0]).toMatchObject({
+      targetUri: 'file:///locales/en.default.json',
+      targetRange: {
+        start: { line: 2, character: expect.any(Number) },
+        end: { line: 2, character: expect.any(Number) },
+      },
+    });
+  });
+
+  it('returns null for non-existent translation key', async () => {
+    const liquidContent = '{{ "unknown.key" | t }}';
+    documentManager.open('file:///templates/products.liquid', liquidContent, 1);
+
+    const params: DefinitionParams = {
+      textDocument: { uri: 'file:///templates/products.liquid' },
+      position: { line: 0, character: 7 }, // Position within "unknown.key"
+    };
+
+    const result = await provider.definitions(params);
+
+    assert(result === null);
+  });
+});

package/src/definitions/providers/TranslationStringDefinitionProvider.ts

@@ -0,0 +1,72 @@
+import { LiquidHtmlNode, NodeTypes } from '@platformos/liquid-html-parser';
+import { SourceCodeType, nodeAtPath } from '@platformos/platformos-check-common';
+import {
+  DefinitionParams,
+  DefinitionLink,
+  Range,
+  LocationLink,
+} from 'vscode-languageserver-protocol';
+import { DocumentManager, AugmentedJsonSourceCode } from '../../documents';
+import { BaseDefinitionProvider } from '../BaseDefinitionProvider';
+
+export class TranslationStringDefinitionProvider implements BaseDefinitionProvider {
+  constructor(
+    private documentManager: DocumentManager,
+    private getDefaultLocaleSourceCode: (uri: string) => Promise<AugmentedJsonSourceCode | null>,
+  ) {}
+
+  async definitions(
+    params: DefinitionParams,
+    node: LiquidHtmlNode,
+    ancestors: LiquidHtmlNode[],
+  ): Promise<DefinitionLink[]> {
+    const doc = this.documentManager.get(params.textDocument.uri)?.textDocument;
+    if (!doc) return [];
+
+    // We want {{ node | t }}
+    if (node.type !== NodeTypes.String) return [];
+    const parent = ancestors.at(-1);
+    if (!parent || parent.type !== NodeTypes.LiquidVariable) return [];
+
+    // Making sure node is the expression
+    if (parent.expression !== node) return [];
+
+    // We're looking for {{ '...' | t }} or {{ '...' | translate }}
+    if (parent.filters.length === 0 || !['t', 'translate'].includes(parent.filters[0].name)) {
+      return [];
+    }
+
+    // Now we need to find the location of the translation in the translation file
+    const defaultLocaleFile = await this.getDefaultLocaleSourceCode(params.textDocument.uri);
+    if (
+      !defaultLocaleFile ||
+      defaultLocaleFile.type !== SourceCodeType.JSON ||
+      defaultLocaleFile.ast instanceof Error
+    ) {
+      return [];
+    }
+
+    const translationKey = node.value;
+    const translationNode = nodeAtPath(defaultLocaleFile.ast, translationKey.split('.'));
+
+    if (!translationNode) return [];
+
+    const targetRange = Range.create(
+      defaultLocaleFile.textDocument.positionAt(translationNode.loc.start.offset),
+      defaultLocaleFile.textDocument.positionAt(translationNode.loc.end.offset),
+    );
+    const originRange = Range.create(
+      doc.positionAt(node.position.start),
+      doc.positionAt(node.position.end),
+    );
+
+    return [
+      LocationLink.create(
+        defaultLocaleFile.textDocument.uri,
+        targetRange,
+        targetRange,
+        originRange,
+      ),
+    ];
+  }
+}

package/src/diagnostics/DiagnosticsManager.spec.ts

@@ -0,0 +1,79 @@
+import { Offense, SourceCodeType } from '@platformos/platformos-check-common';
+import { vi, expect, describe, it, beforeEach } from 'vitest';
+import { Connection, Diagnostic, Range } from 'vscode-languageserver';
+import { DiagnosticsManager } from './DiagnosticsManager';
+import { offenseToDiagnostic } from './offenseToDiagnostic';
+
+describe('Module: DiagnosticsManager', () => {
+  let diagnosticsManager: DiagnosticsManager;
+  let connection: { sendDiagnostics: ReturnType<typeof vi.fn> };
+  beforeEach(() => {
+    connection = {
+      sendDiagnostics: vi.fn(),
+    };
+
+    diagnosticsManager = new DiagnosticsManager(connection as any as Connection);
+  });
+
+  it('should send diagnostics on set', () => {
+    const fileURI = 'browser:///input.liquid';
+    const fileVersion = 0;
+    const offenses: Offense[] = [
+      {
+        uri: 'file:///input.liquid',
+        message: 'Test',
+        check: 'TestCheck',
+        start: {
+          character: 0,
+          line: 0,
+          index: 0,
+        },
+        end: {
+          character: 10,
+          line: 0,
+          index: 10,
+        },
+        severity: 0,
+        type: SourceCodeType.LiquidHtml,
+      },
+    ];
+    const diagnostics = offenses.map(offenseToDiagnostic);
+    diagnosticsManager.set(fileURI, fileVersion, offenses);
+    expect(connection.sendDiagnostics).toBeCalledWith({
+      uri: fileURI,
+      version: fileVersion,
+      diagnostics,
+    });
+  });
+
+  it('should sendDiagnostics with an empty array on clear', () => {
+    const fileURI = 'browser:///input.liquid';
+    const fileVersion = 0;
+    const offenses: Offense[] = [
+      {
+        uri: 'file:///input.liquid',
+        message: 'Test',
+        check: 'TestCheck',
+        start: {
+          character: 0,
+          line: 0,
+          index: 0,
+        },
+        end: {
+          character: 10,
+          line: 0,
+          index: 10,
+        },
+        severity: 0,
+        type: SourceCodeType.LiquidHtml,
+      },
+    ];
+    diagnosticsManager.set(fileURI, fileVersion, offenses);
+    diagnosticsManager.clear(fileURI);
+    expect(connection.sendDiagnostics).toBeCalledTimes(2);
+    expect(connection.sendDiagnostics).toHaveBeenLastCalledWith({
+      uri: fileURI,
+      diagnostics: [],
+    });
+  });
+});

package/src/diagnostics/DiagnosticsManager.ts

@@ -0,0 +1,58 @@
+import { Offense } from '@platformos/platformos-check-common';
+import { Connection, Diagnostic, URI } from 'vscode-languageserver';
+import { offenseToDiagnostic } from './offenseToDiagnostic';
+
+/**
+ * Anomalies are used to represent both the diagnostic and offense in a
+ * single type. That way we can make codeAction associations easily.
+ */
+export type Anomaly = {
+  offense: Offense;
+  diagnostic: Diagnostic;
+  id: number;
+};
+
+export type Diagnostics = {
+  uri: string;
+  version: number | undefined;
+  anomalies: Anomaly[];
+};
+
+export class DiagnosticsManager {
+  private diagnostics = new Map<URI, Diagnostics>();
+
+  constructor(private connection: Connection) {}
+
+  get(uri: URI) {
+    return this.diagnostics.get(uri);
+  }
+
+  set(uri: URI, version: number | undefined, offenses: Offense[]) {
+    const anomalies: Anomaly[] = offenses.map((offense, index) => ({
+      offense,
+      diagnostic: offenseToDiagnostic(offense),
+      id: index,
+    }));
+
+    this.diagnostics.set(uri, {
+      uri,
+      version,
+      anomalies,
+    });
+
+    this.connection.sendDiagnostics({
+      uri,
+      version,
+      diagnostics: anomalies.map((a) => a.diagnostic),
+    });
+  }
+
+  clear(uri: URI) {
+    this.diagnostics.delete(uri);
+    this.connection.sendDiagnostics({
+      uri,
+      version: undefined,
+      diagnostics: [],
+    });
+  }
+}

package/src/diagnostics/index.ts

@@ -0,0 +1,2 @@
+export { Anomaly, DiagnosticsManager } from './DiagnosticsManager';
+export { makeRunChecks } from './runChecks';

package/src/diagnostics/offenseToDiagnostic.ts

@@ -0,0 +1,80 @@
+import { Diagnostic, DiagnosticSeverity, Range } from 'vscode-languageserver';
+import { allChecks, Offense, Severity, assertNever } from '@platformos/platformos-check-common';
+
+type CheckToDocsUrl = {
+  [code in string]?: string;
+};
+
+const checkToDocsUrl = allChecks.reduce<CheckToDocsUrl>((acc, checkDescription) => {
+  const url = checkDescription.meta.docs.url;
+  const code = checkDescription.meta.code;
+  if (url !== undefined) {
+    acc[code] = url;
+  }
+  return acc;
+}, {});
+
+export function offenseToDiagnostic(offense: Offense): Diagnostic {
+  const diagnostic = Diagnostic.create(
+    diagnosticRange(offense),
+    offense.message,
+    diagnosticSeverity(offense),
+    offense.check,
+    'theme-check',
+  );
+
+  const url = checkToDocsUrl[offense.check];
+  if (url) {
+    diagnostic.codeDescription = { href: url };
+  }
+
+  return diagnostic;
+}
+
+function diagnosticRange({ start, end }: Offense): Range {
+  return {
+    start: {
+      line: start.line,
+      character: start.character,
+    },
+    end: {
+      line: end.line,
+      character: end.character,
+    },
+  };
+}
+
+function diagnosticSeverity(offense: Offense): DiagnosticSeverity {
+  switch (offense.severity) {
+    case Severity.INFO: {
+      return DiagnosticSeverity.Information;
+    }
+    case Severity.WARNING: {
+      return DiagnosticSeverity.Warning;
+    }
+    case Severity.ERROR: {
+      return DiagnosticSeverity.Error;
+    }
+    default: {
+      return assertNever(offense.severity);
+    }
+  }
+}
+
+export function offenseSeverity(diagnostic: Diagnostic): Severity {
+  switch (diagnostic.severity) {
+    case DiagnosticSeverity.Hint:
+    case DiagnosticSeverity.Information: {
+      return Severity.INFO;
+    }
+    case DiagnosticSeverity.Warning: {
+      return Severity.WARNING;
+    }
+    case DiagnosticSeverity.Error: {
+      return Severity.ERROR;
+    }
+    default: {
+      return Severity.INFO;
+    }
+  }
+}