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

package/src/hover/providers/LiquidFilterHoverProvider.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 LiquidFilterHoverProvider implements BaseHoverProvider {
-  constructor(private themeDocset: ThemeDocset) {}
+  constructor(private platformosDocset: PlatformOSDocset) {}
 
   async hover(currentNode: LiquidHtmlNode): Promise<Hover | null> {
     if (currentNode.type !== NodeTypes.LiquidFilter) {
@@ -13,7 +13,7 @@ export class LiquidFilterHoverProvider implements BaseHoverProvider {
     }
 
     const name = currentNode.name;
-    const entries = await this.themeDocset.filters();
+    const entries = await this.platformosDocset.filters();
     const entry = entries.find((entry) => entry.name === name);
     if (!entry) {
       return null;

package/src/hover/providers/LiquidObjectAttributeHoverProvider.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';
 
@@ -57,10 +57,8 @@ describe('Module: LiquidObjectAttributeHoverProvider', async () => {
         objects: async () => _objects,
         liquidDrops: async () => _objects,
         tags: async () => [],
-        systemTranslations: async () => ({}),
       },
       new TranslationProvider(new MockFileSystem({})),
-      async (_rootUri: string) => ({}) as MetafieldDefinitionMap,
     );
   });
 

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,16 +1,16 @@
 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';
 
-const uri = 'file:///snippets/product-card.liquid';
+const uri = 'file:///app/views/partials/product-card.liquid';
 
-describe('Module: RenderSnippetHoverProvider', async () => {
+describe('Module: RenderPartialHoverProvider', async () => {
   let provider: HoverProvider;
-  const mockSnippetDefinition: DocDefinition = {
+  const mockPartialDefinition: DocDefinition = {
     uri,
     liquidDoc: {
       parameters: [
@@ -36,10 +36,10 @@ describe('Module: RenderSnippetHoverProvider', async () => {
   };
 
   describe('hover', () => {
-    it('should return snippet definition with all parameters', async () => {
-      provider = createProvider(async () => mockSnippetDefinition);
+    it('should return partial definition with all parameters', async () => {
+      provider = createProvider(async () => mockPartialDefinition);
       // prettier-ignore
-      const expectedHoverContent = 
+      const expectedHoverContent =
 `### product-card
 
 **Description:**
@@ -59,13 +59,13 @@ This is a description
     });
 
     it('should return nothing if not in render tag', async () => {
-      await expect(provider).to.hover(`{% assign asdf = 'snip█pet' %}`, null);
-      await expect(provider).to.hover(`{{ 'snip█pet' }}`, null);
+      await expect(provider).to.hover(`{% assign asdf = 'any-str█ing' %}`, null);
+      await expect(provider).to.hover(`{{ 'any-str█ing' }}`, null);
     });
   });
 });
 
-const createProvider = (getSnippetDefinition: GetDocDefinitionForURI) => {
+const createProvider = (getPartialDefinition: GetDocDefinitionForURI) => {
   return new HoverProvider(
     new DocumentManager(),
     {
@@ -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,
+    getPartialDefinition,
   );
 };

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,17 +1,17 @@
 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';
 
-const uri = 'file:///snippets/product-card.liquid';
+const uri = 'file:///app/views/partials/product-card.liquid';
 
-describe('Module: RenderSnippetParameterHoverProvider', async () => {
+describe('Module: RenderPartialParameterHoverProvider', async () => {
   let provider: HoverProvider;
-  let getSnippetDefinition: GetDocDefinitionForURI;
-  const mockSnippetDefinition: DocDefinition = {
+  let getPartialDefinition: GetDocDefinitionForURI;
+  const mockPartialDefinition: DocDefinition = {
     uri,
     liquidDoc: {
       parameters: [
@@ -28,12 +28,12 @@ describe('Module: RenderSnippetParameterHoverProvider', async () => {
 
   describe('hover', () => {
     beforeEach(() => {
-      provider = createProvider(async () => mockSnippetDefinition);
+      provider = createProvider(async () => mockPartialDefinition);
     });
 
     it('should return null if doc definition not found', async () => {
-      getSnippetDefinition = async () => undefined;
-      provider = createProvider(getSnippetDefinition);
+      getPartialDefinition = async () => undefined;
+      provider = createProvider(getPartialDefinition);
       await expect(provider).to.hover(`{% render 'product-card' tit█le: 'value' %}`, null);
     });
 
@@ -50,7 +50,7 @@ describe('Module: RenderSnippetParameterHoverProvider', async () => {
   });
 });
 
-const createProvider = (getSnippetDefinition: GetDocDefinitionForURI) => {
+const createProvider = (getPartialDefinition: GetDocDefinitionForURI) => {
   return new HoverProvider(
     new DocumentManager(),
     {
@@ -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,
+    getPartialDefinition,
   );
 };

package/src/hover/providers/RenderPartialParameterHoverProvider.ts

@@ -17,15 +17,14 @@ export class RenderPartialParameterHoverProvider implements BaseHoverProvider {
       currentNode.type !== NodeTypes.NamedArgument ||
       !parentNode ||
       parentNode.type !== NodeTypes.RenderMarkup ||
-      parentNode.snippet.type !== NodeTypes.String
+      parentNode.partial.type !== NodeTypes.String
     ) {
       return null;
     }
 
     const docDefinition = await this.getDocDefinitionForURI(
       params.textDocument.uri,
-      'app/views/partials',
-      parentNode.snippet.value,
+      parentNode.partial.value,
     );
 
     const paramName = currentNode.name;

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

@@ -1,5 +1,5 @@
 import {
-  Config as ThemeCheckConfig,
+  Config as PlatformOSCheckConfig,
   allChecks,
   recommended as recommendedChecks,
   SourceCodeType,
@@ -11,19 +11,16 @@ 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';
 export { startServer } from './server';
 export {
-  ThemeCheckConfig,
+  PlatformOSCheckConfig,
   recommendedChecks,
   allChecks,
   AbstractFileSystem,

package/src/internal-types.ts

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