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

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

@@ -1,7 +1,7 @@
 import { describe, beforeEach, it, expect } from 'vitest';
 import { DocumentManager } from '../../documents';
 import { HoverProvider } from '../HoverProvider';
-import { MetafieldDefinitionMap, ObjectEntry } from '@platformos/platformos-check-common';
+import { ObjectEntry } from '@platformos/platformos-check-common';
 import { TranslationProvider } from '@platformos/platformos-common';
 import { MockFileSystem } from '@platformos/platformos-check-common/src/test';
 
@@ -11,29 +11,36 @@ describe('Module: LiquidObjectHoverProvider', async () => {
   beforeEach(async () => {
     const _objects: ObjectEntry[] = [
       {
-        name: 'product',
-        description: 'product description',
+        name: 'context',
+        description: 'context description',
+        access: { global: true, parents: [], template: [] },
         return_type: [],
         properties: [
           {
-            name: 'featured_image',
-            return_type: [{ type: 'image', name: '' }],
+            name: 'posts',
+            return_type: [{ type: 'array', array_value: 'post' }],
           },
           {
-            name: 'title',
-            return_type: [{ type: 'string', name: '' }],
+            name: 'current_user',
+            return_type: [{ type: 'current_user', name: '' }],
           },
-          { name: 'metafields' },
         ],
       },
       {
-        name: 'all_products',
-        return_type: [{ type: 'array', array_value: 'product' }],
-      },
-      {
-        name: 'paginate',
-        access: { global: false, parents: [], template: [] },
+        name: 'post',
+        description: 'post description',
         return_type: [],
+        properties: [
+          {
+            name: 'thumbnail',
+            return_type: [{ type: 'image', name: '' }],
+          },
+          {
+            name: 'title',
+            return_type: [{ type: 'string', name: '' }],
+          },
+          { name: 'metadata' },
+        ],
       },
       {
         name: 'forloop',
@@ -50,46 +57,10 @@ describe('Module: LiquidObjectHoverProvider', async () => {
         description: 'image description',
         access: { global: false, parents: [], template: [] },
       },
-      {
-        name: 'section',
-        access: { global: false, parents: [], template: [] },
-      },
-      {
-        name: 'block',
-        access: { global: false, parents: [], template: [] },
-      },
       {
         name: 'app',
         access: { global: false, parents: [], template: [] },
       },
-      {
-        name: 'predictive_search',
-        access: { global: false, parents: [], template: [] },
-      },
-      {
-        name: 'recommendations',
-        access: { global: false, parents: [], template: [] },
-      },
-      {
-        name: 'metafield',
-        access: {
-          global: false,
-          template: [],
-          parents: [],
-        },
-        properties: [
-          {
-            name: 'type',
-            description: 'the type of the metafield',
-            return_type: [{ type: 'string', name: '' }],
-          },
-          {
-            name: 'value',
-            description: 'the value of the metafield',
-            return_type: [{ type: 'untyped', name: '' }],
-          },
-        ],
-      },
     ];
 
     provider = new HoverProvider(
@@ -100,80 +71,41 @@ describe('Module: LiquidObjectHoverProvider', async () => {
         objects: async () => _objects,
         liquidDrops: async () => _objects,
         tags: async () => [],
-        systemTranslations: async () => ({}),
       },
       new TranslationProvider(new MockFileSystem({})),
-      async (_uri: string) => {
-        return {
-          article: [],
-          blog: [],
-          collection: [],
-          company: [],
-          company_location: [],
-          location: [],
-          market: [],
-          order: [],
-          page: [],
-          product: [
-            {
-              key: 'color',
-              name: 'color',
-              namespace: 'custom',
-              description: 'the color of the product',
-              type: {
-                category: 'COLOR',
-                name: 'color',
-              },
-            },
-          ],
-          variant: [],
-          shop: [],
-        } as MetafieldDefinitionMap;
-      },
     );
   });
 
-  it('should return the hover description of the object', async () => {
+  it('should return the hover description of the global object', async () => {
     const contexts = [
-      '{{ pro█duct }}',
-      '{{ product█ }}',
-      '{% echo product█ %}',
-      '{% liquid\n echo product█ %}',
-      '{% assign x = product %}{{ x█ }}',
-      '{% for x in all_products %}{{ x█ }}{% endfor %}',
-      '{% assign x = all_products[0] %}{{ x█ }}',
-      '{% assign x█ = all_products[0] %}',
-      // '{% for x█ in all_products %}{{ x }}{% endfor %}', // not supported yet...
+      '{{ con█text }}',
+      '{{ context█ }}',
+      '{% echo context█ %}',
+      '{% liquid\n echo context█ %}',
+      '{% assign x = context %}{{ x█ }}',
     ];
     for (const context of contexts) {
-      await expect(provider).to.hover(context, expect.stringContaining('product description'));
-      await expect(provider).to.hover(context, expect.stringMatching(/##* \w+: `product`/));
+      await expect(provider).to.hover(context, expect.stringContaining('context description'));
+      await expect(provider).to.hover(context, expect.stringMatching(/##* \w+: `context`/));
     }
   });
 
-  it('should support paginate inside paginate tags', async () => {
-    const context = `
-      {% paginate all_products by 5 %}
-        {{ paginate█ }}
-      {% endpaginate %}
-    `;
-    await expect(provider).to.hover(context, expect.stringMatching(/##* paginate: `paginate`/));
-    await expect(provider).to.hover('{{ paginate█ }}', null);
-  });
-
-  it('should support form inside form tags', async () => {
-    const context = `
-      {% form all_products by 5 %}
-        {{ form█ }}
-      {% endform %}
-    `;
-    await expect(provider).to.hover(context, expect.stringMatching(/##* form: `form`/));
-    await expect(provider).to.hover('{{ form█ }}', null);
+  it('should return the hover description of an array item object', async () => {
+    const contexts = [
+      '{% for x in context.posts %}{{ x█ }}{% endfor %}',
+      '{% assign x = context.posts[0] %}{{ x█ }}',
+      '{% assign x█ = context.posts[0] %}',
+      // '{% for x█ in context.posts %}{{ x }}{% endfor %}', // not supported yet...
+    ];
+    for (const context of contexts) {
+      await expect(provider).to.hover(context, expect.stringContaining('post description'));
+      await expect(provider).to.hover(context, expect.stringMatching(/##* \w+: `post`/));
+    }
   });
 
   it('should support forloop inside for tags', async () => {
     const context = `
-      {% for p in all_products %}
+      {% for p in context.posts %}
         {{ forloop█ }}
       {% endfor %}
     `;
@@ -183,7 +115,7 @@ describe('Module: LiquidObjectHoverProvider', async () => {
 
   it('should support tablerowloop inside tablerow tags', async () => {
     const context = `
-      {% tablerow p in all_products %}
+      {% tablerow p in context.posts %}
         {{ tablerowloop█ }}
       {% endtablerow %}
     `;
@@ -220,12 +152,8 @@ describe('Module: LiquidObjectHoverProvider', async () => {
 
   it('should support contextual objects by relative path', async () => {
     const contexts: [string, string][] = [
-      ['section', 'sections/my-section.liquid'],
-      ['block', 'blocks/my-block.liquid'],
-      ['predictive_search', 'sections/predictive-search.liquid'],
-      ['recommendations', 'sections/recommendations.liquid'],
-      ['app', 'blocks/recommendations.liquid'],
       ['app', 'app/views/partials/recommendations.liquid'],
+      ['app', 'app/lib/helpers/my-helper.liquid'],
     ];
     for (const [object, relativePath] of contexts) {
       const source = `{{ ${object}█ }}`;
@@ -237,38 +165,27 @@ describe('Module: LiquidObjectHoverProvider', async () => {
     }
   });
 
-  it('should support metafields', async () => {
-    await expect(provider).to.hover(
-      '{{ product.metafields.custom█ }}',
-      '### custom: `product_metafield_custom`',
-    );
-    await expect(provider).to.hover(
-      '{{ product.metafields.custom.color█ }}',
-      '### color: `metafield_color`\nthe color of the product',
-    );
-  });
-
   it('should return null when hovering over an undefined variable', async () => {
     await expect(provider).to.hover(`{{ unknown█ }}`, null);
   });
 
   it('should return something if the thing is knowingly untyped', async () => {
     await expect(provider).to.hover(
-      `{% assign src = product.featured_image.src %}{{ src█ }}`,
+      `{% assign src = context.posts[0].thumbnail.src %}{{ src█ }}`,
       `### src: \`untyped\``,
     );
   });
 
   it('should still return null when hovering over an unknown variable out of scope', async () => {
     await expect(provider).to.hover(
-      `{% for p in all_products %}
+      `{% for p in context.posts %}
         {{ forloop█ }}
       {% endfor %}
       {{ forloop }}`,
       expect.stringMatching(/##* forloop: `forloop`/),
     );
     await expect(provider).to.hover(
-      `{% for p in all_products %}
+      `{% for p in context.posts %}
         {{ forloop }}
       {% endfor %}
       {{ forloop█ }}`,

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

@@ -1,7 +1,6 @@
 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';
 
@@ -20,10 +19,8 @@ describe('Module: LiquidTagHoverProvider', async () => {
           { name: 'if', description: 'if statement description' },
           { name: 'echo', description: 'echo description' },
         ],
-        systemTranslations: async () => ({}),
       },
       new TranslationProvider(new MockFileSystem({})),
-      async (_rootUri: string) => ({} as MetafieldDefinitionMap),
     );
   });
 

package/src/hover/providers/LiquidTagHoverProvider.ts

@@ -1,11 +1,11 @@
 import { NodeTypes } from '@platformos/liquid-html-parser';
-import { LiquidHtmlNode, ThemeDocset } from '@platformos/platformos-check-common';
+import { LiquidHtmlNode, PlatformOSDocset } from '@platformos/platformos-check-common';
 import { Hover } from 'vscode-languageserver';
 import { render } from '../../docset';
 import { BaseHoverProvider } from '../BaseHoverProvider';
 
 export class LiquidTagHoverProvider implements BaseHoverProvider {
-  constructor(public themeDocset: ThemeDocset) {}
+  constructor(public platformosDocset: PlatformOSDocset) {}
 
   async hover(currentNode: LiquidHtmlNode): Promise<Hover | null> {
     if (
@@ -17,7 +17,7 @@ export class LiquidTagHoverProvider implements BaseHoverProvider {
     }
 
     const name = currentNode.name;
-    const entries = await this.themeDocset.tags();
+    const entries = await this.platformosDocset.tags();
     const entry = entries.find((entry) => entry.name === name);
     if (!entry) {
       return null;

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

@@ -1,7 +1,7 @@
 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';
@@ -74,12 +74,9 @@ const createProvider = (getSnippetDefinition: GetDocDefinitionForURI) => {
       objects: async () => [],
       liquidDrops: async () => [],
       tags: async () => [],
-      systemTranslations: async () => ({}),
     },
     new TranslationProvider(new MockFileSystem({})),
-    async (_rootUri: string) => ({} as MetafieldDefinitionMap),
     async () => ({}),
-    async () => [],
     getSnippetDefinition,
   );
 };

package/src/hover/providers/RenderPartialHoverProvider.ts

@@ -22,11 +22,7 @@ export class RenderPartialHoverProvider implements BaseHoverProvider {
     }
 
     const partialName = currentNode.value;
-    const docDefinition = await this.getDocDefinitionForURI(
-      params.textDocument.uri,
-      'app/views/partials',
-      partialName,
-    );
+    const docDefinition = await this.getDocDefinitionForURI(params.textDocument.uri, partialName);
 
     return {
       contents: {

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

@@ -1,7 +1,7 @@
 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';
@@ -59,12 +59,9 @@ const createProvider = (getSnippetDefinition: GetDocDefinitionForURI) => {
       objects: async () => [],
       liquidDrops: async () => [],
       tags: async () => [],
-      systemTranslations: async () => ({}),
     },
     new TranslationProvider(new MockFileSystem({})),
-    async (_rootUri: string) => ({} as MetafieldDefinitionMap),
     async () => ({}),
-    async () => [],
     getSnippetDefinition,
   );
 };

package/src/hover/providers/RenderPartialParameterHoverProvider.ts

@@ -24,7 +24,6 @@ export class RenderPartialParameterHoverProvider implements BaseHoverProvider {
 
     const docDefinition = await this.getDocDefinitionForURI(
       params.textDocument.uri,
-      'app/views/partials',
       parentNode.snippet.value,
     );
 

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

@@ -1,7 +1,7 @@
 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';
 
@@ -17,7 +17,6 @@ describe('Module: TranslationHoverProvider', async () => {
         objects: async () => [],
         liquidDrops: async () => [],
         tags: async () => [],
-        systemTranslations: async () => ({}),
       },
       new TranslationProvider(
         new MockFileSystem({
@@ -32,8 +31,6 @@ describe('Module: TranslationHoverProvider', async () => {
       `,
         }),
       ),
-      async (_rootUri: string) => ({} as MetafieldDefinitionMap),
-      undefined,
       undefined,
       undefined,
       async () => '.',

package/src/hover/providers/TranslationHoverProvider.ts

@@ -6,13 +6,13 @@ 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';
+import { FindAppRootURI } from '../../../src/internal-types';
 
 export class TranslationHoverProvider implements BaseHoverProvider {
   constructor(
     public documentManager: DocumentManager,
     private translationProvider: TranslationProvider,
-    private findThemeRootURI: FindThemeRootURI,
+    private findAppRootURI: FindAppRootURI,
   ) {}
 
   async hover(
@@ -33,7 +33,7 @@ export class TranslationHoverProvider implements BaseHoverProvider {
       return null;
     }
 
-    const root = await this.findThemeRootURI(params.textDocument.uri);
+    const root = await this.findAppRootURI(params.textDocument.uri);
     if (!root) {
       return null;
     }

package/src/index.ts

@@ -11,13 +11,10 @@ export * from './types';
 export { visit } from '@platformos/platformos-check-common';
 export {
   Reference,
-  ThemeGraph,
+  AppGraph,
   SerializableEdge,
   SerializableNode,
-  ThemeModule,
-  CssModule,
-  JsonModule,
-  JavaScriptModule,
+  AppModule,
   LiquidModule,
 } from '@platformos/platformos-graph';
 export { debounce, memo, parseJSON, ArgumentTypes } from './utils';

package/src/internal-types.ts

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

package/src/json/JSONContributions.ts

@@ -1,10 +1,3 @@
-import {
-  AppBlockSchema,
-  parseJSON,
-  SectionSchema,
-  SourceCodeType,
-  ThemeBlockSchema,
-} from '@platformos/platformos-check-common';
 import {
   CompletionsCollector,
   JSONPath,
@@ -12,30 +5,14 @@ import {
   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.
@@ -47,28 +24,9 @@ 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),
-    ];
+  constructor(private documentManager: DocumentManager) {
+    this.hoverProviders = [new TranslationPathHoverProvider()];
+    this.completionProviders = [];
   }
 
   async getInfoContribution(uri: string, location: JSONPath): Promise<MarkedString[]> {
@@ -130,21 +88,6 @@ export class JSONContributions implements JSONWorkerContribution {
   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;
+    return { doc };
   }
 }