@platformos/platformos-language-server-common 0.0.2

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

@@ -0,0 +1,59 @@
+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: TranslationHoverProvider', 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({
+          'app/translations/en/general.yml': `
+        en:
+          general:
+            password: 'password'
+            username_html: '<b>username</b>'
+            comments:
+              one: '{{ count }} comment'
+              other: '{{ count }} comments'
+      `,
+        }),
+      ),
+      async (_rootUri: string) => ({} as MetafieldDefinitionMap),
+      undefined,
+      undefined,
+      undefined,
+      async () => '.',
+    );
+  });
+
+  it('should return the hover description of the translation string', async () => {
+    await expect(provider).to.hover(`{{ '█general.password' | t }}`, 'password');
+    await expect(provider).to.hover(
+      `{{ 'general█.username_html' | t }}`,
+      expect.stringMatching('<b>username</b>'),
+    );
+    await expect(provider).to.hover(
+      `{{ 'general█.comments' | translate }}`,
+      expect.stringMatching(/one(.|\n)*comment(.|\n)*other(.|\n)*comments/),
+    );
+  });
+
+  it('should return nothing if there are no translations for that string', async () => {
+    await expect(provider).to.hover(`{{ 'general.█password' | not_a_translation_filter }}`, null);
+    await expect(provider).to.hover(`{{ 'general.█nope' | t }}`, null);
+  });
+});

package/src/hover/providers/TranslationHoverProvider.ts

@@ -0,0 +1,61 @@
+import { NodeTypes } from '@platformos/liquid-html-parser';
+import { LiquidHtmlNode } from '@platformos/platformos-check-common';
+import { Hover, HoverParams } from 'vscode-languageserver';
+import { DocumentManager } from '../../documents';
+import { renderTranslation } from '../../translations';
+import { BaseHoverProvider } from '../BaseHoverProvider';
+import { TranslationProvider } from '@platformos/platformos-common';
+import { URI } from 'vscode-uri';
+import { FindThemeRootURI } from '../../../src/internal-types';
+
+export class TranslationHoverProvider implements BaseHoverProvider {
+  constructor(
+    public documentManager: DocumentManager,
+    private translationProvider: TranslationProvider,
+    private findThemeRootURI: FindThemeRootURI,
+  ) {}
+
+  async hover(
+    currentNode: LiquidHtmlNode,
+    ancestors: LiquidHtmlNode[],
+    params: HoverParams,
+  ): Promise<Hover | null> {
+    const parentNode = ancestors.at(-1);
+    if (
+      currentNode.type !== NodeTypes.String ||
+      !parentNode ||
+      parentNode.type !== NodeTypes.LiquidVariable
+    ) {
+      return null;
+    }
+
+    if (!parentNode.filters[0] || !['t', 'translate'].includes(parentNode.filters[0].name)) {
+      return null;
+    }
+
+    const root = await this.findThemeRootURI(params.textDocument.uri);
+    if (!root) {
+      return null;
+    }
+    const translation = await this.translationProvider.translate(
+      URI.parse(root),
+      currentNode.value,
+      'en',
+    );
+    const document = this.documentManager.get(params.textDocument.uri)?.textDocument;
+    if (!translation || !document) {
+      return null;
+    }
+
+    return {
+      contents: {
+        kind: 'markdown',
+        value: renderTranslation(translation),
+      },
+      range: {
+        start: document.positionAt(currentNode.position.start),
+        end: document.positionAt(currentNode.position.end),
+      },
+    };
+  }
+}

package/src/hover/providers/index.ts

@@ -0,0 +1,11 @@
+export { LiquidTagHoverProvider } from './LiquidTagHoverProvider';
+export { LiquidFilterHoverProvider } from './LiquidFilterHoverProvider';
+export { LiquidFilterArgumentHoverProvider } from './LiquidFilterArgumentHoverProvider';
+export { LiquidObjectHoverProvider } from './LiquidObjectHoverProvider';
+export { LiquidObjectAttributeHoverProvider } from './LiquidObjectAttributeHoverProvider';
+export { HtmlTagHoverProvider } from './HtmlTagHoverProvider';
+export { HtmlAttributeHoverProvider } from './HtmlAttributeHoverProvider';
+export { HtmlAttributeValueHoverProvider } from './HtmlAttributeValueHoverProvider';
+export { TranslationHoverProvider } from './TranslationHoverProvider';
+export { RenderPartialHoverProvider } from './RenderPartialHoverProvider';
+export { RenderPartialParameterHoverProvider } from './RenderPartialParameterHoverProvider';

package/src/index.spec.ts

@@ -0,0 +1,8 @@
+import { expect, describe, it } from 'vitest';
+import { startServer } from './index';
+
+describe('Module: index (common)', () => {
+  it('should exist and run', () => {
+    expect(startServer).to.exist;
+  });
+});

package/src/index.ts

@@ -0,0 +1,34 @@
+import {
+  Config as ThemeCheckConfig,
+  allChecks,
+  recommended as recommendedChecks,
+  SourceCodeType,
+} from '@platformos/platformos-check-common';
+
+import { AbstractFileSystem, FileStat, FileTuple, FileType } from '@platformos/platformos-common';
+
+export * from './types';
+export { visit } from '@platformos/platformos-check-common';
+export {
+  Reference,
+  ThemeGraph,
+  SerializableEdge,
+  SerializableNode,
+  ThemeModule,
+  CssModule,
+  JsonModule,
+  JavaScriptModule,
+  LiquidModule,
+} from '@platformos/platformos-graph';
+export { debounce, memo, parseJSON, ArgumentTypes } from './utils';
+export { startServer } from './server';
+export {
+  ThemeCheckConfig,
+  recommendedChecks,
+  allChecks,
+  AbstractFileSystem,
+  FileStat,
+  FileTuple,
+  FileType,
+  SourceCodeType,
+};

package/src/internal-types.ts

@@ -0,0 +1 @@
+export type FindThemeRootURI = (uri: string) => Promise<string | null>;

package/src/json/JSONContributions.ts

@@ -0,0 +1,150 @@
+import {
+  AppBlockSchema,
+  parseJSON,
+  SectionSchema,
+  SourceCodeType,
+  ThemeBlockSchema,
+} from '@platformos/platformos-check-common';
+import {
+  CompletionsCollector,
+  JSONPath,
+  JSONWorkerContribution,
+  MarkedString,
+} from 'vscode-json-languageservice';
+import { AugmentedSourceCode, DocumentManager } from '../documents';
+import { GetTranslationsForURI } from '../translations';
+import { JSONCompletionProvider } from './completions/JSONCompletionProvider';
+import { BlockTypeCompletionProvider } from './completions/providers/BlockTypeCompletionProvider';
+import { ReferencedBlockTypeCompletionProvider } from './completions/providers/ReferencedBlockTypeCompletionProvider';
+import { SchemaTranslationsCompletionProvider } from './completions/providers/SchemaTranslationCompletionProvider';
+import { JSONHoverProvider } from './hover/JSONHoverProvider';
+import { SchemaTranslationHoverProvider } from './hover/providers/SchemaTranslationHoverProvider';
+import { TranslationPathHoverProvider } from './hover/providers/TranslationPathHoverProvider';
+import { RequestContext } from './RequestContext';
+import { findSchemaNode } from './utils';
+import { SettingsPropertyCompletionProvider } from './completions/providers/SettingsPropertyCompletionProvider';
+import { SettingsHoverProvider } from './hover/providers/SettingsHoverProvider';
+import { BlockSettingsPropertyCompletionProvider } from './completions/providers/BlockSettingsPropertyCompletionProvider';
+import { BlockSettingsHoverProvider } from './hover/providers/BlockSettingsHoverProvider';
+
+/** The getInfoContribution API will only fallback if we return undefined synchronously */
+const SKIP_CONTRIBUTION = undefined as any;
+
+export type GetThemeBlockSchema = (
+  uri: string,
+  name: string,
+) => Promise<SectionSchema | ThemeBlockSchema | AppBlockSchema | undefined>;
+export type GetThemeBlockNames = (uri: string, includePrivate: boolean) => Promise<string[]>;
+
+/**
+ * I'm not a fan of how json-languageservice does its feature contributions. It's too different
+ * from everything else we do in here.
+ *
+ * Instead, we'll have this little adapter that makes the completions and hover providers feel
+ * a bit more familiar.
+ */
+export class JSONContributions implements JSONWorkerContribution {
+  private hoverProviders: JSONHoverProvider[];
+  private completionProviders: JSONCompletionProvider[];
+
+  constructor(
+    private documentManager: DocumentManager,
+    getDefaultSchemaTranslations: GetTranslationsForURI,
+    getThemeBlockNames: GetThemeBlockNames,
+    getThemeBlockSchema: GetThemeBlockSchema,
+  ) {
+    this.hoverProviders = [
+      new TranslationPathHoverProvider(),
+      new SchemaTranslationHoverProvider(getDefaultSchemaTranslations),
+      new SettingsHoverProvider(getDefaultSchemaTranslations),
+      new BlockSettingsHoverProvider(getDefaultSchemaTranslations, getThemeBlockSchema),
+    ];
+    this.completionProviders = [
+      new SchemaTranslationsCompletionProvider(getDefaultSchemaTranslations),
+      new BlockTypeCompletionProvider(getThemeBlockNames),
+      new ReferencedBlockTypeCompletionProvider(getThemeBlockNames, getThemeBlockSchema),
+      new BlockSettingsPropertyCompletionProvider(
+        getDefaultSchemaTranslations,
+        getThemeBlockSchema,
+      ),
+      new SettingsPropertyCompletionProvider(getDefaultSchemaTranslations),
+    ];
+  }
+
+  async getInfoContribution(uri: string, location: JSONPath): Promise<MarkedString[]> {
+    const doc = this.documentManager.get(uri);
+    if (!doc) return SKIP_CONTRIBUTION;
+    const context = await this.getContext(doc);
+    const provider = this.hoverProviders.find((p) => p.canHover(context, location));
+    if (!provider) return SKIP_CONTRIBUTION;
+    return provider.hover(context, location);
+  }
+
+  async collectPropertyCompletions(
+    uri: string,
+    location: JSONPath,
+    // Don't know what those three are for.
+    _currentWord: string,
+    _addValue: boolean,
+    _isLast: boolean,
+    result: CompletionsCollector,
+  ): Promise<void> {
+    const doc = this.documentManager.get(uri);
+    if (!doc || doc.ast instanceof Error) return;
+
+    const providers = this.completionProviders.filter((provider) => provider.completeProperty);
+    const data = [];
+    for (const provider of providers) {
+      data.push(await provider.completeProperty!(await this.getContext(doc), location));
+    }
+    const items = await Promise.all(data);
+
+    for (const item of items.flat()) {
+      result.add(item);
+    }
+  }
+
+  async collectValueCompletions(
+    uri: string,
+    location: JSONPath,
+    propertyKey: string,
+    result: CompletionsCollector,
+  ): Promise<void> {
+    const doc = this.documentManager.get(uri);
+    if (!doc || doc.ast instanceof Error) return;
+    const providers = this.completionProviders.filter((provider) => provider.completeValue);
+    const data = [];
+    for (const provider of providers) {
+      data.push(
+        await provider.completeValue!(await this.getContext(doc), location.concat(propertyKey)),
+      );
+    }
+    const items = await Promise.all(data);
+
+    for (const item of items.flat()) {
+      result.add(item);
+    }
+  }
+
+  /** I'm not sure we want to do anything with that... but TS requires us to have it */
+  async collectDefaultCompletions(_uri: string, _result: CompletionsCollector): Promise<void> {}
+
+  private async getContext(doc: AugmentedSourceCode): Promise<RequestContext> {
+    const context: RequestContext = {
+      doc,
+    };
+
+    if (doc.type === SourceCodeType.LiquidHtml && !(doc.ast instanceof Error)) {
+      const schema = await findSchemaNode(doc.ast);
+      if (!schema) return SKIP_CONTRIBUTION;
+      const jsonString = schema?.source.slice(
+        schema.blockStartPosition.end,
+        schema.blockEndPosition.start,
+      );
+      context.schema = schema;
+      context.parsed = parseJSON(jsonString);
+    }
+
+    return context;
+  }
+}