@platformos/platformos-language-server-common 0.0.7 → 0.0.8

package/src/css/CSSLanguageService.ts

@@ -1,113 +1,129 @@
-import { LiquidRawTag, NodeTypes } from '@platformos/liquid-html-parser';
-import { Mode, Modes, SourceCodeType, findCurrentNode } from '@platformos/platformos-check-common';
-import { LanguageService, Stylesheet, getCSSLanguageService } from 'vscode-css-languageservice';
+import { getCSSLanguageService, LanguageService } from 'vscode-css-languageservice';
+import {
+  HtmlRawNode,
+  LiquidHtmlNode,
+  NodeTypes,
+  RawMarkupKinds,
+  walk,
+} from '@platformos/liquid-html-parser';
+import { isError, SourceCodeType } from '@platformos/platformos-check-common';
 import {
   CompletionItem,
   CompletionList,
   CompletionParams,
-  Diagnostic,
-  DocumentDiagnosticParams,
   Hover,
   HoverParams,
   ClientCapabilities as LSPClientCapabilities,
+  Position,
 } from 'vscode-languageserver';
 import { TextDocument } from 'vscode-languageserver-textdocument';
 import { DocumentManager } from '../documents';
 
 export class CSSLanguageService {
   private service: LanguageService | null = null;
+  // Standalone .css files — managed independently of DocumentManager
+  private cssDocuments: Map<string, TextDocument> = new Map();
 
   constructor(private documentManager: DocumentManager) {}
 
-  async setup(clientCapabilities: LSPClientCapabilities) {
-    this.service = getCSSLanguageService({
-      clientCapabilities,
-    });
+  setup(clientCapabilities: LSPClientCapabilities) {
+    this.service = getCSSLanguageService({ clientCapabilities });
   }
 
-  async completions(params: CompletionParams): Promise<null | CompletionList | CompletionItem[]> {
-    const service = this.service;
-    if (!service) return null;
-    const documents = this.getDocuments(params, service);
-    if (!documents) return null;
-    const [stylesheetTextDocument, stylesheetDocument] = documents;
-    return service.doComplete(stylesheetTextDocument, params.position, stylesheetDocument);
+  open(uri: string, source: string, version: number) {
+    this.cssDocuments.set(uri, TextDocument.create(uri, 'css', version, source));
+  }
+
+  change(uri: string, source: string, version: number) {
+    const existing = this.cssDocuments.get(uri);
+    if (existing) {
+      this.cssDocuments.set(uri, TextDocument.update(existing, [{ text: source }], version));
+    } else {
+      this.open(uri, source, version);
+    }
   }
 
-  async diagnostics(params: DocumentDiagnosticParams): Promise<Diagnostic[]> {
+  close(uri: string) {
+    this.cssDocuments.delete(uri);
+  }
+
+  async completions(params: CompletionParams): Promise<CompletionList | CompletionItem[] | null> {
     const service = this.service;
-    if (!service) return [];
-    const documents = this.getDocuments(params, service);
-    if (!documents) return [];
-    const [stylesheetTextDocument, stylesheetDocument] = documents;
-    return service.doValidation(stylesheetTextDocument, stylesheetDocument);
+    if (!service) return null;
+
+    const uri = params.textDocument.uri;
+
+    if (uri.endsWith('.css')) {
+      const textDoc = this.cssDocuments.get(uri);
+      if (!textDoc) return null;
+      const stylesheet = service.parseStylesheet(textDoc);
+      return service.doComplete(textDoc, params.position, stylesheet);
+    }
+
+    const embedded = this.findEmbeddedCSS(uri, params.position);
+    if (!embedded) return null;
+    const stylesheet = service.parseStylesheet(embedded.virtualDoc);
+    return service.doComplete(embedded.virtualDoc, params.position, stylesheet);
   }
 
   async hover(params: HoverParams): Promise<Hover | null> {
     const service = this.service;
     if (!service) return null;
-    const documents = this.getDocuments(params, service);
-    if (!documents) return null;
-    const [stylesheetTextDocument, stylesheetDocument] = documents;
-    return service.doHover(stylesheetTextDocument, params.position, stylesheetDocument);
+
+    const uri = params.textDocument.uri;
+
+    if (uri.endsWith('.css')) {
+      const textDoc = this.cssDocuments.get(uri);
+      if (!textDoc) return null;
+      const stylesheet = service.parseStylesheet(textDoc);
+      return service.doHover(textDoc, params.position, stylesheet);
+    }
+
+    const embedded = this.findEmbeddedCSS(uri, params.position);
+    if (!embedded) return null;
+    const stylesheet = service.parseStylesheet(embedded.virtualDoc);
+    return service.doHover(embedded.virtualDoc, params.position, stylesheet);
   }
 
-  private getDocuments(
-    params: HoverParams | CompletionParams | DocumentDiagnosticParams,
-    service: LanguageService,
-  ): [TextDocument, Stylesheet] | null {
-    const document = this.documentManager.get(params.textDocument.uri);
-    if (!document) return null;
-
-    switch (document.type) {
-      case SourceCodeType.GraphQL:
-      case SourceCodeType.JSON: {
-        return null;
-      }
-      case SourceCodeType.LiquidHtml: {
-        if (document.ast instanceof Error) return null;
-        const textDocument = document.textDocument;
-        let offset = 0;
-        let isDiagnostics = false;
-        if ('position' in params && params.position.line !== 0 && params.position.character !== 0) {
-          offset = textDocument.offsetAt(params.position);
-        } else {
-          const stylesheetIndex = document.source.indexOf('{% stylesheet %}');
-          offset = stylesheetIndex;
-          isDiagnostics = true;
-        }
-        const [node, ancestors] = findCurrentNode(document.ast, offset);
-        let stylesheetTag = [...ancestors].find(
-          (node): node is LiquidRawTag =>
-            node.type === NodeTypes.LiquidRawTag && node.name === 'stylesheet',
-        );
-        if (isDiagnostics && 'children' in node && node.children) {
-          stylesheetTag = node.children.find(
-            (node): node is LiquidRawTag =>
-              node.type === NodeTypes.LiquidRawTag && node.name === 'stylesheet',
-          );
-        }
+  /**
+   * Finds the <style> block under the cursor in a .liquid file and builds a
+   * virtual CSS TextDocument whose line numbers align with the parent document.
+   *
+   * Strategy: prefix body.value with N newlines where N equals the line number
+   * of blockStartPosition.end. This keeps line numbers in sync so the same LSP
+   * Position can be passed directly to the CSS service.
+   *
+   * Note: character offsets are only accurate when <style> is on its own line
+   * (the typical case). Inline `<style>css</style>` is not handled perfectly.
+   */
+  private findEmbeddedCSS(uri: string, position: Position): { virtualDoc: TextDocument } | null {
+    const document = this.documentManager.get(uri);
+    if (!document || document.type !== SourceCodeType.LiquidHtml) return null;
+    if (isError(document.ast)) return null;
 
-        if (!stylesheetTag) return null;
-
-        const schemaLineNumber = textDocument.positionAt(stylesheetTag.blockStartPosition.end).line;
-        // Hacking away "same line numbers" here by prefixing the file with newlines
-        // This way params.position will be at the same line number in this fake jsonTextDocument
-        // Which means that the completions will be at the same line number in the Liquid document
-        const stylesheetString =
-          Array(schemaLineNumber).fill('\n').join('') +
-          stylesheetTag.source
-            .slice(stylesheetTag.blockStartPosition.end, stylesheetTag.blockEndPosition.start)
-            .replace(/\n$/, ''); // Remove trailing newline so parsing errors don't show up on `{% endstylesheet %}`
-        const stylesheetTextDocument = TextDocument.create(
-          textDocument.uri,
-          'json',
-          textDocument.version,
-          stylesheetString,
-        );
-        const stylesheetDocument = service.parseStylesheet(stylesheetTextDocument);
-        return [stylesheetTextDocument, stylesheetDocument];
+    const offset = document.textDocument.offsetAt(position);
+
+    let foundNode: HtmlRawNode | null = null;
+    walk(document.ast as LiquidHtmlNode, (node) => {
+      if (node.type === NodeTypes.HtmlRawNode) {
+        const rawNode = node as HtmlRawNode;
+        if (
+          rawNode.body.kind === RawMarkupKinds.css &&
+          rawNode.blockStartPosition.end <= offset &&
+          offset <= rawNode.blockEndPosition.start
+        ) {
+          foundNode = rawNode;
+        }
       }
-    }
+    });
+
+    if (!foundNode) return null;
+
+    const node = foundNode as HtmlRawNode;
+    const bodyStartPos = document.textDocument.positionAt(node.blockStartPosition.end);
+    const prefix = '\n'.repeat(bodyStartPos.line);
+    const virtualDoc = TextDocument.create(uri + '#style', 'css', 0, prefix + node.body.value);
+
+    return { virtualDoc };
   }
 }

package/src/definitions/DefinitionProvider.ts

@@ -3,7 +3,6 @@ import { DefinitionLink, DefinitionParams } from 'vscode-languageserver';
 
 import { AugmentedJsonSourceCode, DocumentManager } from '../documents';
 import { BaseDefinitionProvider } from './BaseDefinitionProvider';
-import { SchemaTranslationStringDefinitionProvider } from './providers/SchemaTranslationStringDefinitionProvider';
 import { TranslationStringDefinitionProvider } from './providers/TranslationStringDefinitionProvider';
 
 export class DefinitionProvider {
@@ -12,14 +11,9 @@ export class DefinitionProvider {
   constructor(
     private documentManager: DocumentManager,
     getDefaultLocaleSourceCode: (uri: string) => Promise<AugmentedJsonSourceCode | null>,
-    getDefaultSchemaLocaleSourceCode: (uri: string) => Promise<AugmentedJsonSourceCode | null>,
   ) {
     this.providers = [
       new TranslationStringDefinitionProvider(documentManager, getDefaultLocaleSourceCode),
-      new SchemaTranslationStringDefinitionProvider(
-        documentManager,
-        getDefaultSchemaLocaleSourceCode,
-      ),
     ];
   }
 

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

@@ -33,11 +33,7 @@ describe('Module: TranslationStringDefinitionProvider', () => {
       };
     };
 
-    provider = new DefinitionProvider(
-      documentManager,
-      mockGetDefaultLocaleSourceCode,
-      async () => null,
-    );
+    provider = new DefinitionProvider(documentManager, mockGetDefaultLocaleSourceCode);
   });
 
   it('finds the definition of existing translation keys', async () => {

package/src/diagnostics/offenseToDiagnostic.ts

@@ -20,7 +20,7 @@ export function offenseToDiagnostic(offense: Offense): Diagnostic {
     offense.message,
     diagnosticSeverity(offense),
     offense.check,
-    'theme-check',
+    'platformos-check',
   );
 
   const url = checkToDocsUrl[offense.check];

package/src/diagnostics/runChecks.spec.ts

@@ -45,7 +45,7 @@ describe('Module: runChecks', () => {
   let connection: { sendDiagnostics: ReturnType<typeof vi.fn> };
   let runChecks: ReturnType<typeof makeRunChecks>;
   let fs: MockFileSystem;
-  const rootUri = path.normalize('browser:///theme');
+  const rootUri = path.normalize('browser:///app');
   const fileUri = path.join(rootUri, 'app', 'input.liquid');
 
   beforeEach(() => {
@@ -67,18 +67,16 @@ describe('Module: runChecks', () => {
     runChecks = makeRunChecks(documentManager, diagnosticsManager, {
       fs,
       loadConfig: async () => ({
-        context: 'theme' as const,
         settings: {},
         checks: [LiquidFilter],
         rootUri,
       }),
-      themeDocset: {
+      platformosDocset: {
         graphQL: async () => null,
         filters: async () => [],
         objects: async () => [],
         liquidDrops: async () => [],
         tags: async () => [],
-        systemTranslations: async () => ({}),
       },
       jsonValidationSet: {
         schemas: async () => [],
@@ -98,7 +96,7 @@ describe('Module: runChecks', () => {
       version: fileVersion,
       diagnostics: [
         {
-          source: 'theme-check',
+          source: 'platformos-check',
           code: 'LiquidFilter',
           message: 'Liquid filter can not be used',
           severity: 1,
@@ -147,7 +145,7 @@ describe('Module: runChecks', () => {
         fileVersion: 0,
         diagnostics: [
           {
-            source: 'theme-check',
+            source: 'platformos-check',
             code: 'LiquidFilter',
             message: 'Liquid filter can not be used',
             severity: 1,
@@ -171,7 +169,7 @@ describe('Module: runChecks', () => {
         fileVersion: 0,
         diagnostics: [
           {
-            source: 'theme-check',
+            source: 'platformos-check',
             code: 'LiquidFilter',
             message: 'Liquid filter can not be used',
             severity: 1,
@@ -206,17 +204,17 @@ describe('Module: runChecks', () => {
   });
 
   it('should use the contents of the default translations file buffer (if any) instead of the result of the factory', async () => {
-    const defaultPath = 'locales/en.default.json';
+    const defaultPath = 'app/translations/en.yml';
     const defaultURI = path.join(rootUri, ...defaultPath.split('/'));
-    const frPath = 'locales/fr.json';
+    const frPath = 'app/translations/fr.yml';
     const frURI = path.join(rootUri, ...frPath.split('/'));
     const files = {
       '.pos': '',
       'app/test': '',
       '.git/test': 'test',
       'modules/test': 'test',
-      [defaultPath]: JSON.stringify({ hello: 'hello' }),
-      [frPath]: JSON.stringify({ hello: 'bonjour', hi: 'salut' }),
+      [defaultPath]: 'en:\n  hello: hello',
+      [frPath]: 'fr:\n  hello: bonjour\n  hi: salut',
     };
 
     const matchingTranslation = allChecks.filter((c) => c.meta.code === 'MatchingTranslations');
@@ -224,18 +222,16 @@ describe('Module: runChecks', () => {
     runChecks = makeRunChecks(documentManager, diagnosticsManager, {
       fs: new MockFileSystem(files, rootUri),
       loadConfig: async () => ({
-        context: 'theme',
         settings: {},
         checks: matchingTranslation,
         rootUri: rootUri,
       }),
-      themeDocset: {
+      platformosDocset: {
         graphQL: async () => null,
         filters: async () => [],
         objects: async () => [],
         liquidDrops: async () => [],
         tags: async () => [],
-        systemTranslations: async () => ({}),
       },
       jsonValidationSet: {
         schemas: async () => [],
@@ -251,20 +247,16 @@ describe('Module: runChecks', () => {
         version: 0,
         diagnostics: expect.arrayContaining([
           {
-            source: 'theme-check',
+            source: 'platformos-check',
             code: 'MatchingTranslations',
             codeDescription: { href: expect.any(String) },
             message: `A default translation for 'hi' does not exist`,
             severity: 1,
             range: {
-              end: {
-                character: 31,
-                line: 0,
-              },
-              start: {
-                character: 19,
-                line: 0,
-              },
+              // 'fr:\n  hello: bonjour\n  hi: salut'
+              // line 2 starts at offset 21, 'hi: salut' spans offsets 23-31
+              start: { line: 2, character: 2 },
+              end: { line: 2, character: 10 },
             },
           },
         ]),
@@ -273,7 +265,7 @@ describe('Module: runChecks', () => {
 
     // Change the contents of the defaultURI buffer, expect frURI to be fixed
     documentManager.open(defaultURI, files[defaultPath], 0);
-    documentManager.change(defaultURI, JSON.stringify({ hello: 'hello', hi: 'hi' }), 1);
+    documentManager.change(defaultURI, 'en:\n  hello: hello\n  hi: hi', 1);
     connection.sendDiagnostics.mockClear();
     await runChecks([frURI]);
     expect(connection.sendDiagnostics).toHaveBeenCalledWith({

package/src/diagnostics/runChecks.ts

@@ -2,21 +2,15 @@ import {
   check,
   findRoot,
   makeFileExists,
-  Offense,
   path,
   Reference,
-  SectionSchema,
-  Severity,
   SourceCodeType,
-  ThemeBlockSchema,
 } from '@platformos/platformos-check-common';
 
-import { CSSLanguageService } from '../css/CSSLanguageService';
-import { AugmentedSourceCode, DocumentManager } from '../documents';
+import { DocumentManager } from '../documents';
 import { Dependencies } from '../types';
 import { DiagnosticsManager } from './DiagnosticsManager';
-import { offenseSeverity } from './offenseToDiagnostic';
-import { ThemeGraphManager } from '../server/ThemeGraphManager';
+import { AppGraphManager } from '../server/AppGraphManager';
 
 export function makeRunChecks(
   documentManager: DocumentManager,
@@ -24,18 +18,12 @@ export function makeRunChecks(
   {
     fs,
     loadConfig,
-    themeDocset,
+    platformosDocset,
     jsonValidationSet,
-    getMetafieldDefinitions,
-    cssLanguageService,
-    themeGraphManager,
+    appGraphManager,
     includeFilesFromDisk,
-  }: Pick<
-    Dependencies,
-    'fs' | 'loadConfig' | 'themeDocset' | 'jsonValidationSet' | 'getMetafieldDefinitions'
-  > & {
-    cssLanguageService?: CSSLanguageService;
-    themeGraphManager?: ThemeGraphManager;
+  }: Pick<Dependencies, 'fs' | 'loadConfig' | 'platformosDocset' | 'jsonValidationSet'> & {
+    appGraphManager?: AppGraphManager;
     includeFilesFromDisk?: () => boolean;
   },
 ) {
@@ -45,10 +33,10 @@ export function makeRunChecks(
     // workspaces.
     //
     // e.g. if a user renames
-    //  theme1/snippets/a.liquid to
-    //  theme1/snippets/b.liquid
+    //  app1/app/views/partials/a.liquid to
+    //  app1/app/views/partials/b.liquid
     //
-    // then we recheck theme1
+    // then we recheck app1
     const fileExists = makeFileExists(fs);
     const rootURIs = await Promise.all(triggerURIs.map((uri) => findRoot(uri, fileExists)));
     const deduplicatedRootURIs = new Set<string>(rootURIs.filter((x): x is string => !!x));
@@ -58,42 +46,16 @@ export function makeRunChecks(
 
     async function runChecksForRoot(configFileRootUri: string) {
       const config = await loadConfig(configFileRootUri, fs);
-      const theme = documentManager.theme(config.rootUri, includeFilesFromDisk?.());
+      const app = documentManager.app(config.rootUri, includeFilesFromDisk?.());
 
-      const cssOffenses = cssLanguageService
-        ? await Promise.all(
-            theme.map((sourceCode) => getCSSDiagnostics(cssLanguageService, sourceCode)),
-          ).then((offenses) => offenses.flat())
-        : [];
-
-      const themeOffenses = await check(theme, config, {
+      const appOffenses = await check(app, config, {
         fs,
-        themeDocset,
+        platformosDocset,
         jsonValidationSet,
-        getMetafieldDefinitions,
 
         async getReferences(uri: string): Promise<Reference[]> {
-          if (!themeGraphManager) return [];
-          return themeGraphManager.getReferences(uri);
-        },
-
-        // TODO should do something for app blocks?
-        async getBlockSchema(name) {
-          // We won't preload here. If it's available, we'll give it. Otherwise expect nothing.
-          const uri = path.join(config.rootUri, 'blocks', `${name}.liquid`);
-          const doc = documentManager.get(uri);
-          if (doc?.type !== SourceCodeType.LiquidHtml) return undefined;
-          const schema = await doc.getSchema();
-          return schema as ThemeBlockSchema | undefined;
-        },
-
-        async getSectionSchema(name) {
-          // We won't preload here. If it's available, we'll give it. Otherwise expect nothing.
-          const uri = path.join(config.rootUri, 'sections', `${name}.liquid`);
-          const doc = documentManager.get(uri);
-          if (doc?.type !== SourceCodeType.LiquidHtml) return undefined;
-          const schema = await doc.getSchema();
-          return schema as SectionSchema | undefined;
+          if (!appGraphManager) return [];
+          return appGraphManager.getReferences(uri);
         },
 
         async getDocDefinition(relativePath) {
@@ -103,50 +65,14 @@ export function makeRunChecks(
           return doc.getLiquidDoc();
         },
       });
-      const offenses = [...themeOffenses, ...cssOffenses];
 
-      // We iterate over the theme files (as opposed to offenses) because if
+      // We iterate over the app files (as opposed to offenses) because if
       // there were offenses before, we need to send an empty array to clear
       // them.
-      for (const sourceCode of theme) {
-        const sourceCodeOffenses = offenses.filter((offense) => offense.uri === sourceCode.uri);
+      for (const sourceCode of app) {
+        const sourceCodeOffenses = appOffenses.filter((offense) => offense.uri === sourceCode.uri);
         diagnosticsManager.set(sourceCode.uri, sourceCode.version, sourceCodeOffenses);
       }
     }
   };
 }
-
-async function getCSSDiagnostics(
-  cssLanguageService: CSSLanguageService,
-  sourceCode: AugmentedSourceCode,
-): Promise<Offense[]> {
-  if (sourceCode.type !== SourceCodeType.LiquidHtml) {
-    return [];
-  }
-
-  const diagnostics = await cssLanguageService.diagnostics({
-    textDocument: { uri: sourceCode.uri },
-  });
-
-  return diagnostics
-    .map(
-      (diagnostic): Offense => ({
-        check: 'css',
-        message: diagnostic.message,
-        end: {
-          index: sourceCode.textDocument.offsetAt(diagnostic.range.end),
-          line: diagnostic.range.end.line,
-          character: diagnostic.range.end.character,
-        },
-        start: {
-          index: sourceCode.textDocument.offsetAt(diagnostic.range.start),
-          line: diagnostic.range.start.line,
-          character: diagnostic.range.start.character,
-        },
-        severity: offenseSeverity(diagnostic),
-        uri: sourceCode.uri,
-        type: SourceCodeType.LiquidHtml,
-      }),
-    )
-    .filter((offense) => offense.severity !== Severity.INFO);
-}

package/src/docset/MarkdownRenderer.ts

@@ -62,7 +62,7 @@ function sanitize(s: string | undefined) {
     ?.replace(/(^|\n+)>/g, ' ')
     .replace(/>/g, '>')
     .replace(/&lt;/g, '<')
-    .replace(/\]\(\//g, '](https://shopify.dev/')
+    .replace(/\]\(\//g, '](https://documentation.platformos.com/')
     .trim();
 }
 

package/src/documentLinks/DocumentLinksProvider.ts

@@ -6,13 +6,13 @@ import { URI, Utils } from 'vscode-uri';
 
 import { visit, Visitor } from '@platformos/platformos-check-common';
 import { DocumentManager } from '../documents';
-import { FindThemeRootURI } from '../internal-types';
+import { FindAppRootURI } from '../internal-types';
 import { DocumentsLocator, TranslationProvider } from '@platformos/platformos-common';
 
 export class DocumentLinksProvider {
   constructor(
     private documentManager: DocumentManager,
-    private findThemeRootURI: FindThemeRootURI,
+    private findAppRootURI: FindAppRootURI,
     private documentsLocator: DocumentsLocator,
     private translationProvider: TranslationProvider,
   ) {}
@@ -27,7 +27,7 @@ export class DocumentLinksProvider {
       return [];
     }
 
-    const rootUri = await this.findThemeRootURI(uriString);
+    const rootUri = await this.findAppRootURI(uriString);
     if (!rootUri) {
       return [];
     }