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

package/src/json/JSONLanguageService.spec.ts

@@ -1,424 +0,0 @@
-import { Mode, Translations } from '@platformos/platformos-check-common';
-import { assert, beforeEach, describe, expect, it } from 'vitest';
-import { DocumentManager } from '../documents';
-import { JSONLanguageService } from './JSONLanguageService';
-import { getRequestParams, isCompletionList } from './test/test-helpers';
-
-const simplifiedSectionSchema = JSON.stringify({
-  $schema: 'http://json-schema.org/draft-07/schema#',
-  type: 'object',
-  additionalProperties: false,
-  properties: {
-    name: {
-      type: 'string',
-      description: 'The section title shown in the theme editor',
-    },
-    class: {
-      type: 'string',
-      description: 'Additional CSS class for the section',
-    },
-    disabled_on: {
-      type: 'string',
-    },
-  },
-});
-
-const simplifiedTaeBlockSchema = JSON.stringify({
-  $schema: 'http://json-schema.org/draft-07/schema#',
-  type: 'object',
-  additionalProperties: false,
-  properties: {
-    name: {
-      type: 'string',
-      description: 'The section title shown in the theme editor',
-    },
-    class: {
-      type: 'string',
-      description: 'Additional CSS class for the section',
-    },
-    javascript: {
-      type: 'string',
-      description: 'Haha this one is different',
-    },
-  },
-});
-
-const simplifiedTranslationSchema = JSON.stringify({
-  $schema: 'https://json-schema.org/draft/2020-12/schema',
-  type: 'object',
-  additionalProperties: {
-    oneOf: [
-      {
-        type: 'string',
-      },
-      {
-        $ref: '#/$defs/pluralizedString',
-      },
-      {
-        $ref: '#',
-      },
-    ],
-  },
-  $defs: {
-    pluralizedString: {
-      type: 'object',
-      properties: {
-        one: {
-          type: 'string',
-          description: 'Translation for the singular form',
-        },
-        other: {
-          type: 'string',
-          description: 'Translation for the plural form',
-        },
-      },
-      additionalProperties: false,
-      description: 'An object representing a pluralized translation string',
-    },
-  },
-});
-
-describe('Module: JSONLanguageService', () => {
-  let jsonLanguageService: JSONLanguageService;
-  let documentManager: DocumentManager;
-  let schemaTranslations: Translations;
-
-  beforeEach(async () => {
-    schemaTranslations = {};
-    documentManager = new DocumentManager(
-      undefined,
-      undefined,
-      undefined,
-      async () => 'theme', // theme schema
-      async () => false, // invalid
-    );
-    jsonLanguageService = new JSONLanguageService(
-      documentManager,
-      {
-        schemas: async (mode: Mode) => [
-          {
-            uri: 'https://shopify.dev/section-schema.json',
-            schema: simplifiedSectionSchema,
-            fileMatch: ['**/sections/*.liquid'],
-          },
-          {
-            uri: 'https://shopify.dev/translation-schema.json',
-            schema: simplifiedTranslationSchema,
-            fileMatch: ['**/locales/*.json'],
-          },
-          {
-            uri:
-              mode === 'theme'
-                ? 'https://shopify.dev/block-schema.json'
-                : 'https://shopify.dev/block-tae-schema.json',
-            schema: mode === 'theme' ? simplifiedSectionSchema : simplifiedTaeBlockSchema,
-            fileMatch: ['**/blocks/*.liquid'],
-          },
-        ],
-      },
-      () => Promise.resolve(schemaTranslations),
-      (uri: string) => Promise.resolve(uri.includes('tae') ? 'app' : 'theme'),
-      () => Promise.resolve([]),
-      async () => undefined,
-      async () => 'file:///test-root',
-    );
-
-    await jsonLanguageService.setup({
-      textDocument: {
-        completion: {
-          contextSupport: true,
-          completionItem: {
-            snippetSupport: true,
-            commitCharactersSupport: true,
-            documentationFormat: ['markdown'],
-            deprecatedSupport: true,
-            preselectSupport: true,
-          },
-        },
-      },
-    });
-  });
-
-  describe('completions', () => {
-    it('should return section JSON schema completions in a section file {% schema %}', async () => {
-      const params = getRequestParams(
-        documentManager,
-        'sections/section.liquid',
-        `
-          <div>hello world</div>
-          {% schema %}
-            {
-              "name": "My section",
-              "█"
-            }
-          {% endschema %}
-        `,
-      );
-
-      const completions = await jsonLanguageService.completions(params);
-      assert(isCompletionList(completions));
-      expect(completions.items).to.have.lengthOf(2);
-      expect(completions.items[0].label).to.equal('class');
-      expect(completions.items[0].documentation).to.equal('Additional CSS class for the section');
-    });
-
-    it('should return translation key completions in a theme translation file', async () => {
-      const paths = [
-        'locales/en.default.json',
-        'locales/en.default.schema.json',
-        'locales/fr.json',
-        'locales/fr.schema.json',
-      ];
-      for (const path of paths) {
-        const params = getRequestParams(
-          documentManager,
-          path,
-          `
-            {
-              "general": {
-                "hello": {
-                  "other": "hey folks",
-                  "█"
-                }
-              }
-            }
-          `,
-        );
-        const completions = await jsonLanguageService.completions(params);
-        assert(isCompletionList(completions));
-        expect(completions.items).to.have.lengthOf(1);
-        expect(completions.items[0].label).to.equal('one');
-        expect(completions.items[0].documentation).to.eql('Translation for the singular form');
-      }
-    });
-
-    it('should be possible to offer theme app extension completions in app contexts, and theme completions in theme contexts for blocks', async () => {
-      const testContexts: [Mode, string, string[]][] = [
-        ['theme', 'theme/blocks/block.liquid', ['class', 'disabled_on']],
-        ['app', 'tae/blocks/block.liquid', ['class', 'javascript']],
-      ];
-      for (const [mode, path, expectedRecommendations] of testContexts) {
-        const params = getRequestParams(
-          documentManager,
-          path,
-          `
-          <div>hello world</div>
-          {% schema %}
-            {
-              "name": "My section",
-              "█"
-            }
-          {% endschema %}
-        `,
-        );
-
-        const completions = await jsonLanguageService.completions(params);
-        assert(isCompletionList(completions));
-        expect(completions.items).to.have.lengthOf(expectedRecommendations.length);
-        expect(completions.items).toEqual(
-          expectedRecommendations.map((recommendation) =>
-            expect.objectContaining({ label: recommendation }),
-          ),
-        );
-      }
-    });
-
-    it('should complete t:translations', async () => {
-      schemaTranslations = {
-        general: {
-          hello: 'hello world',
-          hi: 'hi world',
-        },
-      };
-
-      const params = getRequestParams(
-        documentManager,
-        'sections/section.liquid',
-        `
-          <div>hello world</div>
-          {% schema %}
-            {
-              "name": "t:█"
-            }
-          {% endschema %}
-        `,
-      );
-
-      const completions = await jsonLanguageService.completions(params);
-      assert(isCompletionList(completions));
-      expect(completions.items).to.have.lengthOf(2);
-      expect(completions.items[0].label).to.equal('t:general.hello');
-      expect(completions.items[0].documentation).to.eql({
-        kind: 'markdown',
-        value: 'hello world',
-      });
-    });
-  });
-
-  describe('hover', () => {
-    it('should return the translation value of a t:translation', async () => {
-      schemaTranslations = {
-        general: {
-          hello: 'hello world',
-        },
-      };
-      const params = getRequestParams(
-        documentManager,
-        'sections/section.liquid',
-        `
-          <div>hello world</div>
-          {% schema %}
-            {
-              "name": "t:general.hello█"
-            }
-          {% endschema %}
-        `,
-      );
-      const hover = await jsonLanguageService.hover(params);
-      assert(hover !== null);
-      expect(hover.contents).to.eql(['hello world']);
-    });
-
-    it('should return the path of a translation key in a theme translation file', async () => {
-      const paths = ['locales/en.default.json', 'locales/fr.json'];
-      for (const path of paths) {
-        const params = getRequestParams(
-          documentManager,
-          path,
-          `
-            {
-              "general": {
-                "hello█": "world"
-              }
-            }
-          `,
-        );
-        const hover = await jsonLanguageService.hover(params);
-        assert(hover !== null);
-        expect(hover.contents).to.eql([{ language: 'liquid', value: `{{ 'general.hello' | t }}` }]);
-      }
-    });
-
-    it('should return add interpolated variables to the hover', async () => {
-      const paths = ['locales/en.default.json', 'locales/fr.json'];
-      for (const path of paths) {
-        const params = getRequestParams(
-          documentManager,
-          path,
-          `
-            {
-              "general": {
-                "hello█": " {{ var1 }} world {{ var2 }}"
-              }
-            }
-          `,
-        );
-        const hover = await jsonLanguageService.hover(params);
-        assert(hover !== null);
-        expect(hover.contents).to.eql([
-          { language: 'liquid', value: `{{ 'general.hello' | t: var1: var1, var2: var2 }}` },
-        ]);
-      }
-    });
-
-    it('should return translation group hover for non-leaf nodes', async () => {
-      const paths = ['locales/en.default.json', 'locales/fr.json'];
-      for (const path of paths) {
-        const params = getRequestParams(
-          documentManager,
-          path,
-          `
-            {
-              "general█": {
-                "hello": " {{ var1 }} world {{ var2 }}"
-              }
-            }
-          `,
-        );
-        const hover = await jsonLanguageService.hover(params);
-        assert(hover !== null);
-        expect(hover.contents).to.eql([`Translation group: general`]);
-      }
-    });
-
-    it('should return the parent translation key for pluralized translations', async () => {
-      const paths = ['locales/en.default.json', 'locales/fr.json'];
-      for (const path of paths) {
-        const params = getRequestParams(
-          documentManager,
-          path,
-          `
-            {
-              "general": {
-                "one█": " {{ var1 }} world"
-              }
-            }
-          `,
-        );
-        const hover = await jsonLanguageService.hover(params);
-        assert(hover !== null);
-        expect(hover.contents).to.eql([
-          { language: 'liquid', value: `{{ 'general' | t: var1: var1 }}` },
-        ]);
-      }
-    });
-
-    it('should return the t:path of a translation key in a schema translation file', async () => {
-      const paths = ['locales/en.default.schema.json', 'locales/fr.schema.json'];
-      for (const path of paths) {
-        const params = getRequestParams(
-          documentManager,
-          path,
-          `
-            {
-              "general": {
-                "hello█": "world"
-              }
-            }
-          `,
-        );
-        const hover = await jsonLanguageService.hover(params);
-        assert(hover !== null);
-        expect(hover.contents).to.eql([{ language: 'json', value: `"t:general.hello"` }]);
-      }
-    });
-  });
-
-  describe('isValidSchema', () => {
-    it('should return true for a valid schema', async () => {
-      const params = getRequestParams(
-        documentManager,
-        'sections/section.liquid',
-        `
-          <div>hello world</div>
-          {% schema %}
-            { "name": "hello world" }
-          {% endschema %}
-        `,
-      );
-      const isValid = await jsonLanguageService.isValidSchema(
-        params.textDocument.uri,
-        '{ "name": "hello world" }',
-      );
-      expect(isValid).to.be.true;
-    });
-
-    it('should return false for an invalid schema', async () => {
-      const params = getRequestParams(
-        documentManager,
-        'sections/section.liquid',
-        `
-          <div>hello world</div>
-          {% schema %}
-            { "invalid": true }
-          {% endschema %}
-        `,
-      );
-      const isValid = await jsonLanguageService.isValidSchema(
-        params.textDocument.uri,
-        '{ "invalid": true }',
-      );
-      expect(isValid).to.be.false;
-    });
-  });
-});

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

@@ -1,163 +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: BlockSettingsPropertyCompletionProvider', () => {
-  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: 'presets',
-        schemaTemplate: (referencedBlock: object) => {
-          return {
-            presets: [
-              {
-                blocks: [referencedBlock],
-              },
-            ],
-          };
-        },
-      },
-      {
-        label: 'default',
-        schemaTemplate: (referencedBlock: object) => {
-          return {
-            default: {
-              blocks: [referencedBlock],
-            },
-          };
-        },
-      },
-    ];
-
-    for (const test of tests) {
-      describe(`${test.label} block settings`, () => {
-        beforeEach(() => {
-          const testBlockSchema = {
-            settings: [
-              { id: 'custom-setting', label: 'Custom Setting' },
-              { id: 'fake-setting', label: 't:general.fake' },
-              { id: 'no-label' },
-              { nope: 'no-id' },
-            ],
-          };
-          documentManager.open(`${rootUri}/blocks/test-block.liquid`, toSource(testBlockSchema), 1);
-          documentManager.open(`${rootUri}/blocks/no-settings-block.liquid`, toSource({}), 1);
-        });
-
-        it(`completes ${test.label} block settings property when settings exist`, async () => {
-          const schema = {
-            ...test.schemaTemplate({
-              type: 'test-block',
-              settings: {
-                '█': '',
-              },
-            }),
-          };
-          const params = getRequestParams(
-            documentManager,
-            'sections/section.liquid',
-            toSource(schema),
-          );
-          const completions = await jsonLanguageService.completions(params);
-
-          assert(isCompletionList(completions));
-          expect(completions.items).to.have.lengthOf(3);
-          expect(completions.items).toContainEqual(
-            expect.objectContaining({
-              insertText: `"custom-setting"`,
-              documentation: expect.objectContaining({
-                value: 'Custom Setting',
-              }),
-            }),
-          );
-          expect(completions.items).toContainEqual(
-            expect.objectContaining({
-              insertText: `"fake-setting"`,
-              documentation: expect.objectContaining({
-                value: 'Fake Setting',
-              }),
-            }),
-          );
-          expect(completions.items).toContainEqual(
-            expect.objectContaining({
-              insertText: `"no-label"`,
-              documentation: expect.objectContaining({
-                value: '',
-              }),
-            }),
-          );
-        });
-
-        it(`offers no suggestions for ${test.label} block settings property when there are no settings`, async () => {
-          const schema = {
-            ...test.schemaTemplate({
-              type: 'no-settings-block',
-              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);
-        });
-      });
-    }
-  });
-});
-
-function toSource(schema: object) {
-  return `{% schema %}
-  ${JSON.stringify(schema)}
-{% endschema %}`;
-}

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

@@ -1,121 +0,0 @@
-import { JSONPath } from 'vscode-json-languageservice';
-import { GetThemeBlockSchema } from '../../JSONContributions';
-import { RequestContext } from '../../RequestContext';
-import { JSONCompletionItem, JSONCompletionProvider } from '../JSONCompletionProvider';
-import { isBlockFile, isSectionFile } from '../../utils';
-import { deepGet, isError, SourceCodeType } from '@platformos/platformos-check-common';
-import { isSectionOrBlockSchema } from './BlockTypeCompletionProvider';
-import { GetTranslationsForURI } from '../../../translations';
-import { getSectionBlockByName, schemaSettingsPropertyCompletionItems } from '../../schemaSettings';
-
-/**
- * The BlockSettingsPropertyCompletionProvider offers value completions of the
- * `presets.[].(recursive blocks.[]).settings` keys and `defaults.blocks.[].settings` keys inside
- * `{% schema %}` tags.
- *
- * @example
- * {% schema %}
- * {
- *   "presets": [
- *     {
- *       "blocks": [
- *         {
- *           "type": "block-type",
- *           "settings": {
- *             "█"
- *           }
- *         },
- *       ]
- *     },
- *   ],
- *   "default": {
- *     "blocks": [
- *       {
- *         "type": "block-type",
- *         "settings": {
- *           "█"
- *         }
- *       },
- *     ]
- *   }
- * }
- * {% endschema %}
- */
-export class BlockSettingsPropertyCompletionProvider implements JSONCompletionProvider {
-  constructor(
-    private getDefaultSchemaTranslations: GetTranslationsForURI,
-    private getThemeBlockSchema: GetThemeBlockSchema,
-  ) {}
-
-  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) &&
-        (isPresetsBlocksSettingsPath(path) || isDefaultBlocksSettingsPath(path))
-      ) &&
-      !(isBlockFile(doc.uri) && isPresetsBlocksSettingsPath(path))
-    ) {
-      return [];
-    }
-
-    const schema = await doc.getSchema();
-
-    if (!schema || !isSectionOrBlockSchema(schema) || isError(schema.parsed)) {
-      return [];
-    }
-
-    const blockType: string = deepGet(schema.parsed, [...path.slice(0, -1), 'type']);
-
-    if (!blockType) {
-      return [];
-    }
-
-    const translations = await this.getDefaultSchemaTranslations(doc.textDocument.uri);
-
-    const localBlock = getSectionBlockByName(schema.parsed, blockType);
-
-    if (localBlock) {
-      if (localBlock.settings) {
-        return schemaSettingsPropertyCompletionItems(localBlock.settings, translations);
-      }
-    } else {
-      const blockOriginSchema = await this.getThemeBlockSchema(doc.uri, blockType);
-
-      if (
-        !blockOriginSchema ||
-        isError(blockOriginSchema.parsed) ||
-        !isSectionOrBlockSchema(blockOriginSchema)
-      ) {
-        return [];
-      }
-
-      if (
-        !blockOriginSchema.parsed?.settings ||
-        !Array.isArray(blockOriginSchema.parsed?.settings)
-      ) {
-        return [];
-      }
-
-      return schemaSettingsPropertyCompletionItems(blockOriginSchema.parsed.settings, translations);
-    }
-
-    return [];
-  }
-}
-
-// `blocks` can be nested within other `blocks`
-// We need to ensure the last leg of the path is { "blocks": [{ "settings": { "█" } }] }
-function isPresetsBlocksSettingsPath(path: JSONPath) {
-  return path.at(0) === 'presets' && path.at(-3) === 'blocks' && path.at(-1) === 'settings';
-}
-
-// `blocks` inside `default` can't be nested within other `blocks`
-function isDefaultBlocksSettingsPath(path: JSONPath) {
-  return path.at(0) === 'default' && path.at(1) === 'blocks' && path.at(3) === 'settings';
-}