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

package/src/json/completions/providers/SettingsPropertyCompletionProvider.spec.ts

@@ -1,211 +0,0 @@
-import { describe, it, expect, assert, beforeEach } from 'vitest';
-import { JSONLanguageService } from '../../JSONLanguageService';
-import { DocumentManager } from '../../../documents';
-import {
-  getRequestParams,
-  isCompletionList,
-  mockJSONLanguageService,
-} from '../../test/test-helpers';
-
-describe('Unit: SettingsPropertyCompletionProvider', () => {
-  const rootUri = 'file:///root/';
-  let jsonLanguageService: JSONLanguageService;
-  let documentManager: DocumentManager;
-
-  beforeEach(async () => {
-    documentManager = new DocumentManager(
-      undefined, // don't need a fs
-      undefined, // don't need a connection
-      undefined, // don't need client capabilities
-      async () => 'theme', // 'theme' mode
-      async () => false, // schema is invalid for tests
-    );
-    jsonLanguageService = mockJSONLanguageService(
-      rootUri,
-      documentManager,
-      async (_uri: string) => ({
-        general: {
-          fake: 'Fake Setting',
-        },
-      }),
-    );
-
-    await jsonLanguageService.setup({
-      textDocument: {
-        completion: {
-          contextSupport: true,
-          completionItem: {
-            snippetSupport: true,
-            commitCharactersSupport: true,
-            documentationFormat: ['markdown'],
-            deprecatedSupport: true,
-            preselectSupport: true,
-          },
-        },
-      },
-    });
-  });
-
-  describe('section file with valid schema', () => {
-    const tests = [
-      {
-        label: 'preset',
-        schemaTemplate: (setting: object) => {
-          return {
-            presets: [setting],
-          };
-        },
-      },
-      {
-        label: 'default',
-        schemaTemplate: (setting: object) => {
-          return {
-            default: setting,
-          };
-        },
-      },
-    ];
-
-    for (const test of tests) {
-      describe(`${test.label} settings`, () => {
-        it(`completes ${test.label} setting property when settings exist`, async () => {
-          const schema = {
-            settings: [{ id: 'custom-setting' }, { id: 'fake-setting' }, {}],
-            ...test.schemaTemplate({
-              settings: {
-                '█': '',
-              },
-            }),
-          };
-          const source = `
-            {% schema %}
-              ${JSON.stringify(schema)}
-            {% endschema %}
-          `;
-          const params = getRequestParams(documentManager, 'sections/section.liquid', source);
-          const completions = await jsonLanguageService.completions(params);
-
-          assert(isCompletionList(completions));
-          expect(completions.items).to.have.lengthOf(2);
-          expect(completions.items.map((item) => item.label)).to.include.members([
-            `"custom-setting"`,
-            `"fake-setting"`,
-          ]);
-        });
-
-        it(`offers no suggestions for ${test.label} setting property when there are no settings`, async () => {
-          const schema = {
-            ...test.schemaTemplate({
-              settings: {
-                '█': '',
-              },
-            }),
-          };
-          const source = `
-            {% schema %}
-              ${JSON.stringify(schema)}
-            {% endschema %}
-          `;
-          const params = getRequestParams(documentManager, 'sections/section.liquid', source);
-          const completions = await jsonLanguageService.completions(params);
-
-          assert(isCompletionList(completions));
-          expect(completions.items).to.have.lengthOf(0);
-          expect(completions.items.map((item) => item.label)).to.include.members([]);
-        });
-
-        it(`offers ${test.label} setting completion with docs from setting.label`, async () => {
-          const schema = {
-            settings: [
-              { id: 'custom-setting', label: 'Custom Setting' },
-              { id: 'fake-setting', label: 't:general.fake' },
-              {},
-            ],
-            ...test.schemaTemplate({
-              settings: {
-                '█': '',
-              },
-            }),
-          };
-          const source = `
-            {% schema %}
-              ${JSON.stringify(schema)}
-            {% endschema %}
-          `;
-          const params = getRequestParams(documentManager, 'sections/section.liquid', source);
-          const completions = await jsonLanguageService.completions(params);
-
-          assert(isCompletionList(completions));
-          expect(completions.items).to.have.lengthOf(2);
-          expect(completions.items).toEqual(
-            expect.arrayContaining([
-              expect.objectContaining({
-                documentation: { kind: 'markdown', value: 'Custom Setting' },
-              }),
-              expect.objectContaining({
-                documentation: { kind: 'markdown', value: 'Fake Setting' },
-              }),
-            ]),
-          );
-        });
-      });
-    }
-
-    describe('block file with valid schema', () => {
-      it(`offers no suggestions for default setting property when file is block`, async () => {
-        const source = `
-          {% schema %}
-          {
-            "settings": [
-              {"id": "custom-setting"},
-              {"id": "fake-setting"},
-              {},
-            ],
-            "default": {
-              "settings": {
-                "█": ""
-              }
-            }
-          }
-          {% endschema %}
-        `;
-        const params = getRequestParams(documentManager, 'blocks/block.liquid', source);
-        const completions = await jsonLanguageService.completions(params);
-
-        assert(isCompletionList(completions));
-        expect(completions.items).to.have.lengthOf(0);
-        expect(completions.items.map((item) => item.label)).to.include.members([]);
-      });
-    });
-  });
-
-  describe('invalid schema', () => {
-    it('completes preset setting property when settings exist and schema has small errors', async () => {
-      const source = `
-        {% schema %}
-        {
-          "settings": [
-            {"id": "custom-setting"},
-            {"id": "fake-setting"},
-            {},
-          ],
-          "presets": [{
-            "settings": {
-              "█"
-            }
-          }]
-        }
-        {% endschema %}
-      `;
-      const params = getRequestParams(documentManager, 'blocks/block.liquid', source);
-      const completions = await jsonLanguageService.completions(params);
-
-      assert(isCompletionList(completions));
-      expect(completions.items).to.have.lengthOf(2);
-      expect(completions.items.map((item) => item.label)).to.include.members([
-        `"custom-setting"`,
-        `"fake-setting"`,
-      ]);
-    });
-  });
-});

package/src/json/completions/providers/SettingsPropertyCompletionProvider.ts

@@ -1,75 +0,0 @@
-import { isError, SourceCodeType } from '@platformos/platformos-check-common';
-import { JSONPath } from 'vscode-json-languageservice';
-import { JSONCompletionItem } from 'vscode-json-languageservice/lib/umd/jsonContributions';
-import { RequestContext } from '../../RequestContext';
-import { isBlockFile, isSectionFile } from '../../utils';
-import { JSONCompletionProvider } from '../JSONCompletionProvider';
-import { GetTranslationsForURI } from '../../../translations';
-import { isSectionOrBlockSchema } from './BlockTypeCompletionProvider';
-import { schemaSettingsPropertyCompletionItems } from '../../schemaSettings';
-
-/**
- * The SettingsPropertyCompletionProvider offers property completions for:
- * - `presets.[].settings.[]` objects inside `{% schema %}` tag in sections and blocks
- * - `default.settings` object inside `{% schema %}` tag in sections
- *
- * @example
- * {% schema %}
- * {
- *   "presets": [
- *     {
- *       "settings": [
- *         { "█" },
- *       ]
- *     },
- *   ],
- *   "default": {
- *     "settings": {
- *       "█"
- *     }
- *   }
- * }
- * {% endschema %}
- */
-export class SettingsPropertyCompletionProvider implements JSONCompletionProvider {
-  constructor(public getDefaultSchemaTranslations: GetTranslationsForURI) {}
-
-  async completeProperty(context: RequestContext, path: JSONPath): Promise<JSONCompletionItem[]> {
-    const { doc } = context;
-
-    if (doc.type !== SourceCodeType.LiquidHtml) return [];
-
-    // section files can have schemas with `presets` and `default`
-    // block files can have schemas with `presets` only
-    if (
-      !(isSectionFile(doc.uri) && (isPresetSettingsPath(path) || isDefaultSettingsPath(path))) &&
-      !(isBlockFile(doc.uri) && isPresetSettingsPath(path))
-    ) {
-      return [];
-    }
-
-    const schema = await doc.getSchema();
-
-    if (!schema || !isSectionOrBlockSchema(schema) || isError(schema.parsed)) {
-      return [];
-    }
-
-    const parsedSchema = schema.parsed;
-
-    if (!parsedSchema?.settings || !Array.isArray(parsedSchema.settings)) {
-      return [];
-    }
-
-    const translations = await this.getDefaultSchemaTranslations(doc.textDocument.uri);
-
-    return schemaSettingsPropertyCompletionItems(parsedSchema.settings, translations);
-  }
-}
-
-function isPresetSettingsPath(path: JSONPath) {
-  return path.length === 3 && path.at(0) === 'presets' && path.at(2) === 'settings';
-}
-
-function isDefaultSettingsPath(path: JSONPath) {
-  return path.length === 2 && path.at(0) === 'default' && path.at(1) === 'settings';
-}

package/src/json/documentLinks/DocumentLinksProvider.spec.ts

@@ -1,223 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest';
-import { DocumentManager } from '../../documents';
-import { createJSONDocumentLinksVisitor } from './DocumentLinksProvider';
-import { toJSONAST, visit } from '@platformos/platformos-check-common';
-import { URI } from 'vscode-uri';
-import { JSONLanguageService } from '../JSONLanguageService';
-
-describe('JSON Document Links', () => {
-  let documentManager: DocumentManager;
-  let rootUri: string;
-  let uriString: string;
-  let jsonLanguageService: JSONLanguageService;
-
-  beforeEach(async () => {
-    documentManager = new DocumentManager();
-    rootUri = 'file:///path/to/project';
-
-    // Create a minimal JSONLanguageService for testing
-    jsonLanguageService = new JSONLanguageService(
-      documentManager,
-      { schemas: async () => [] },
-      async () => ({}),
-      async () => 'theme',
-      async () => [],
-      async () => undefined,
-      async () => rootUri,
-    );
-
-    // Initialize the service to resolve the initialized promise
-    await jsonLanguageService.setup({});
-  });
-
-  describe('Schema Tags in Liquid Files', () => {
-    it('should return document links for block types in schema tags', async () => {
-      uriString = 'file:///path/to/sections/header.liquid';
-      rootUri = 'file:///path/to/project';
-
-      const schemaContent = `
-        {
-          "name": "Header",
-          "blocks": [
-            { "type": "logo" },
-            { "type": "navigation" }
-          ]
-        }
-      `;
-
-      const liquidContent = `
-        <div>Header content</div>
-        
-        {% schema %}
-        ${schemaContent}
-        {% endschema %}
-      `;
-
-      documentManager.open(uriString, liquidContent, 1);
-
-      const textDocument = documentManager.get(uriString)!.textDocument;
-      const schemaOffset = liquidContent.indexOf(schemaContent);
-
-      const visitor = await createJSONDocumentLinksVisitor(
-        textDocument,
-        URI.parse(rootUri),
-        schemaOffset,
-      );
-      const ast = toJSONAST(schemaContent);
-
-      if (ast instanceof Error) throw ast;
-      const result = await visit(ast, visitor);
-
-      expect(result).toHaveLength(2);
-      expect(result[0].target).toBe('file:///path/to/project/blocks/logo.liquid');
-      expect(result[1].target).toBe('file:///path/to/project/blocks/navigation.liquid');
-    });
-
-    it('should handle section types in schema tags', async () => {
-      uriString = 'file:///path/to/sections/main-collection.liquid';
-      rootUri = 'file:///path/to/project';
-
-      const schemaContent = `
-        {
-          "name": "Collection",
-          "blocks": [
-            {
-              "type": "text",
-              "settings": []
-            }
-          ],
-          "presets": [
-            {
-              "name": "Default",
-              "blocks": [
-                { "type": "text" }
-              ]
-            }
-          ]
-        }
-      `;
-
-      const liquidContent = `
-        <div>Collection content</div>
-        
-        {% schema %}
-        ${schemaContent}
-        {% endschema %}
-      `;
-
-      documentManager.open(uriString, liquidContent, 1);
-
-      const textDocument = documentManager.get(uriString)!.textDocument;
-      const schemaOffset = liquidContent.indexOf(schemaContent);
-
-      const visitor = await createJSONDocumentLinksVisitor(
-        textDocument,
-        URI.parse(rootUri),
-        schemaOffset,
-      );
-      const ast = toJSONAST(schemaContent);
-
-      if (ast instanceof Error) throw ast;
-      const result = await visit(ast, visitor);
-
-      // Should find both block type references (in blocks array and in presets)
-      expect(result).toHaveLength(2);
-      expect(result[0].target).toBe('file:///path/to/project/blocks/text.liquid');
-      expect(result[1].target).toBe('file:///path/to/project/blocks/text.liquid');
-    });
-
-    it('should not create links for special block types in schema tags', async () => {
-      uriString = 'file:///path/to/sections/app-blocks.liquid';
-      rootUri = 'file:///path/to/project';
-
-      const schemaContent = `
-        {
-          "name": "App Blocks",
-          "blocks": [
-            { "type": "@app" },
-            { "type": "@theme" },
-            { "type": "custom-block" }
-          ]
-        }
-      `;
-
-      const liquidContent = `
-        <div>App blocks section</div>
-        
-        {% schema %}
-        ${schemaContent}
-        {% endschema %}
-      `;
-
-      documentManager.open(uriString, liquidContent, 1);
-
-      const textDocument = documentManager.get(uriString)!.textDocument;
-      const schemaOffset = liquidContent.indexOf(schemaContent);
-      const visitor = await createJSONDocumentLinksVisitor(
-        textDocument,
-        URI.parse(rootUri),
-        schemaOffset,
-      );
-      const ast = toJSONAST(schemaContent);
-
-      if (ast instanceof Error) throw ast;
-      const result = await visit(ast, visitor);
-
-      // Should only create link for custom-block, not @app or @theme
-      expect(result).toHaveLength(1);
-      expect(result[0].target).toBe('file:///path/to/project/blocks/custom-block.liquid');
-    });
-  });
-
-  describe('JSON Files', () => {
-    it('should return document links for section types in template JSON files', async () => {
-      uriString = 'file:///path/to/templates/index.json';
-
-      const jsonContent = `{
-        "layout": "theme",
-        "sections": {
-          "header": {
-            "type": "header-section"
-          },
-          "main": {
-            "type": "main-product"
-          }
-        }
-      }`;
-
-      documentManager.open(uriString, jsonContent, 1);
-
-      const result = await jsonLanguageService.documentLinks({
-        textDocument: { uri: uriString },
-      });
-
-      expect(result).toHaveLength(2);
-      expect(result[0].target).toBe('file:///path/to/project/sections/header-section.liquid');
-      expect(result[1].target).toBe('file:///path/to/project/sections/main-product.liquid');
-    });
-
-    it('should return document links for block types in section JSON files', async () => {
-      uriString = 'file:///path/to/sections/settings.json';
-
-      const jsonContent = `{
-        "name": "Section with blocks",
-        "blocks": [
-          { "type": "text" },
-          { "type": "image" },
-          { "type": "@app" }
-        ]
-      }`;
-
-      documentManager.open(uriString, jsonContent, 1);
-
-      const result = await jsonLanguageService.documentLinks({
-        textDocument: { uri: uriString },
-      });
-
-      expect(result).toHaveLength(2);
-      expect(result[0].target).toBe('file:///path/to/project/blocks/text.liquid');
-      expect(result[1].target).toBe('file:///path/to/project/blocks/image.liquid');
-      // @app should not create a link
-    });
-  });
-});

package/src/json/documentLinks/DocumentLinksProvider.ts

@@ -1,61 +0,0 @@
-import { JSONNode, SourceCodeType } from '@platformos/platformos-check-common';
-import { DocumentLink, Range } from 'vscode-languageserver';
-import { TextDocument } from 'vscode-languageserver-textdocument';
-import { URI, Utils } from 'vscode-uri';
-import { Visitor } from '@platformos/platformos-check-common';
-
-export async function createJSONDocumentLinksVisitor(
-  textDocument: TextDocument,
-  root: URI,
-  offset: number = 0,
-): Promise<Visitor<SourceCodeType.JSON, DocumentLink>> {
-  const visitor: Visitor<SourceCodeType.JSON, DocumentLink> = {
-    async Property(node, ancestors) {
-      const origin = jsonPropertyOriginDirectory(ancestors);
-
-      if (!origin) return;
-
-      if (
-        !(
-          node.key.value === 'type' &&
-          node.value.type === 'Literal' &&
-          typeof node.value.value === 'string'
-        )
-      ) {
-        return;
-      }
-
-      if (origin === 'blocks' && ['@app', '@theme'].includes(node.value.value)) {
-        return;
-      }
-
-      return DocumentLink.create(
-        range(textDocument, node.value, offset),
-        Utils.resolvePath(root, origin, node.value.value + '.liquid').toString(),
-      );
-    },
-  };
-  return visitor;
-}
-
-function range(textDocument: TextDocument, node: JSONNode, offset: number): Range {
-  // +1 and -1 to exclude the quotes
-  const start = textDocument.positionAt(offset + node.loc.start.offset + 1);
-  const end = textDocument.positionAt(offset + node.loc.end.offset - 1);
-  return Range.create(start, end);
-}
-
-function jsonPropertyOriginDirectory(ancestors: JSONNode[]): 'sections' | 'blocks' | undefined {
-  for (let i = ancestors.length - 1; i >= 0; i--) {
-    const ancestor = ancestors[i];
-    if (ancestor.type === 'Property') {
-      if (ancestor.key.value === 'blocks') {
-        return 'blocks';
-      }
-      if (ancestor.key.value === 'sections') {
-        return 'sections';
-      }
-    }
-  }
-  return undefined;
-}