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

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

@@ -1,137 +0,0 @@
-import { describe, it, expect, assert, beforeEach } from 'vitest';
-import { JSONLanguageService } from '../../JSONLanguageService';
-import { DocumentManager } from '../../../documents';
-import { getRequestParams, isCompletionList } from '../../test/test-helpers';
-
-/**
- * We only need this because I want to show in the test that @theme and @app are
- * completed by the schema... If you write a test that doesn't have a JOIN on
- * the completions, feel free to not copy paste this...
- */
-const simplifiedBlockSchema = JSON.stringify({
-  $schema: 'http://json-schema.org/draft-07/schema#',
-  type: 'object',
-  additionalProperties: false,
-  properties: {
-    blocks: {
-      type: 'array',
-      items: {
-        type: 'object',
-        required: ['type'],
-        properties: {
-          type: {
-            oneOf: [
-              // blocks[].type is @app, @theme or a string
-              { const: '@app' },
-              { const: '@theme' },
-              {
-                if: { not: { enum: ['@theme', '@app'] } },
-                then: { type: 'string' },
-              },
-            ],
-          },
-        },
-      },
-    },
-  },
-});
-
-describe('Unit: BlockTypeCompletionProvider', () => {
-  let jsonLanguageService: JSONLanguageService;
-  let documentManager: DocumentManager;
-  const blockNames = ['block-1', 'block-2', 'custom-block'];
-
-  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 = new JSONLanguageService(
-      documentManager,
-      {
-        schemas: async () => [
-          {
-            uri: 'https://shopify.dev/block-schema.json',
-            schema: simplifiedBlockSchema,
-            fileMatch: ['**/{blocks,sections}/*.liquid'], // cheating a little here...
-          },
-        ],
-      },
-      async () => ({}),
-      async () => 'theme',
-      async () => blockNames,
-      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('when there are no local blocks', () => {
-    it('completes theme block names', async () => {
-      const source = `
-      hello world
-      {% schema %}
-      {
-        "blocks": [
-          { "type": "█" }
-        ]
-      }
-      {% endschema %}
-      `;
-      const params = getRequestParams(documentManager, 'sections/section.liquid', source);
-
-      const completions = await jsonLanguageService.completions(params);
-
-      assert(isCompletionList(completions));
-      // @app & @theme come from the JSON schema. There's no way to not include them.
-      expect(completions.items).to.have.lengthOf(blockNames.length + ['@app', '@theme'].length);
-      expect(completions.items.map((item) => item.label)).to.include.members([
-        '"@app"',
-        '"@theme"',
-        ...blockNames.map((x) => `"${x}"`),
-      ]);
-    });
-  });
-
-  describe('when there are local blocks', () => {
-    it('does not completes theme block names', async () => {
-      const source = `
-      hello world
-      {% schema %}
-      {
-        "blocks": [
-          { "type": "user-defined", "name": "user defined" }
-          { "type": "█" }
-        ]
-      }
-      {% endschema %}
-      `;
-      const params = getRequestParams(documentManager, 'sections/section.liquid', source);
-
-      const completions = await jsonLanguageService.completions(params);
-
-      assert(isCompletionList(completions));
-      expect(completions.items).to.have.lengthOf(['@app', '@theme'].length);
-      expect(completions.items.map((item) => item.label)).not.to.include.members([
-        ...blockNames.map((x) => `"${x}"`),
-      ]);
-    });
-  });
-});

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

@@ -1,108 +0,0 @@
-import {
-  AppBlockSchema,
-  deepGet,
-  isError,
-  SectionSchema,
-  ThemeBlockSchema,
-  ThemeSchemaType,
-} from '@platformos/platformos-check-common';
-import { JSONPath } from 'vscode-json-languageservice';
-import { JSONCompletionItem } from 'vscode-json-languageservice/lib/umd/jsonContributions';
-import { CompletionItemKind } from 'vscode-languageserver-protocol';
-import { isLiquidRequestContext, RequestContext } from '../../RequestContext';
-import { isSectionOrBlockFile } from '../../utils';
-import { JSONCompletionProvider } from '../JSONCompletionProvider';
-import { GetThemeBlockNames } from '../../JSONContributions';
-
-/**
- * The BlockTypeCompletionProvider offers value completions of the
- * `blocks.[].type` property inside section and theme block `{% schema %}` tags.
- *
- * @example
- * {% schema %}
- * {
- *   "blocks": [
- *     { "type": "█" },
- *   ]
- * }
- * {% endschema %}
- */
-export class BlockTypeCompletionProvider implements JSONCompletionProvider {
-  constructor(private getThemeBlockNames: GetThemeBlockNames) {}
-
-  async completeValue(context: RequestContext, path: JSONPath): Promise<JSONCompletionItem[]> {
-    if (
-      !isSectionOrBlockFile(context.doc.uri) ||
-      !isLiquidRequestContext(context) ||
-      !isBlockDefinitionPath(path)
-    ) {
-      return [];
-    }
-    const { doc } = context;
-    const schema = await doc.getSchema();
-
-    // Can't complete if we can't parse the schema
-    if (!schema || isError(schema.parsed) || !isSectionOrBlockSchema(schema)) {
-      return [];
-    }
-
-    // Local blocks have their type defined in the schema, there's nothing to complete
-    if (hasLocalBlockDefinitions(schema)) return [];
-
-    const blockNames = await this.getThemeBlockNames(doc.uri, true);
-
-    return createBlockNameCompletionItems(blockNames);
-  }
-}
-
-export function createBlockNameCompletionItems(blockNames: string[]) {
-  return blockNames.map((name) => ({
-    kind: CompletionItemKind.Value,
-    label: `"${name}"`,
-    insertText: `"${name}"`,
-  }));
-}
-
-export function isBlockDefinitionPath(path: JSONPath) {
-  return path.at(0) === 'blocks';
-}
-
-export function isPresetBlockPath(path: JSONPath) {
-  return path.at(0) === 'presets';
-}
-
-export function isBlockTypePath(path: JSONPath) {
-  // We have these cases to support:
-  // - top level blocks.[].type
-  // - presets.[](recursive .blocks.[].type)
-  // - presets.[](recursive .blocks.{}.type)
-  const topLevel = path.at(0);
-  if (topLevel !== 'blocks' && topLevel !== 'presets') return false;
-  if (path.length < 4) return false; // minimum path length
-  const [shouldBeBlocks, _idOrIndex, shouldBeType] = path.slice(-3);
-  return shouldBeBlocks === 'blocks' && shouldBeType === 'type';
-}
-
-export function hasLocalBlockDefinitions(schema: SectionSchema | ThemeBlockSchema) {
-  if (schema.type !== ThemeSchemaType.Section || isError(schema.parsed)) return false;
-  const blocks = deepGet(schema.parsed, ['blocks']);
-  if (!blocks || !Array.isArray(blocks)) return false;
-  return blocks.some((block) => block && block.name !== undefined);
-}
-
-export function isLocalBlockDefinition(
-  schema: ThemeBlockSchema | SectionSchema,
-  blockTypePath: JSONPath,
-) {
-  if (schema.type !== ThemeSchemaType.Section) return false;
-  const blockNamePath = [...blockTypePath.slice(0, -1), 'name'];
-  const name = deepGet(schema.parsed, blockNamePath);
-  return name !== undefined;
-}
-
-const SectionOrBlockSchemaTypes = [ThemeSchemaType.Section, ThemeSchemaType.Block];
-export function isSectionOrBlockSchema(
-  schema: SectionSchema | ThemeBlockSchema | AppBlockSchema,
-): schema is SectionSchema | ThemeBlockSchema {
-  return SectionOrBlockSchemaTypes.includes(schema.type);
-}

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

@@ -1,132 +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: ReferencedBlockTypeCompletionProvider', () => {
-  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, undefined, async () => [
-      'block-1',
-      'block-2',
-      'custom-block',
-    ]);
-
-    await jsonLanguageService.setup({
-      textDocument: {
-        completion: {
-          contextSupport: true,
-          completionItem: {
-            snippetSupport: true,
-            commitCharactersSupport: true,
-            documentationFormat: ['markdown'],
-            deprecatedSupport: true,
-            preselectSupport: true,
-          },
-        },
-      },
-    });
-  });
-
-  const tests = [
-    {
-      description: 'select blocks',
-      configured: [{ type: 'block-1' }],
-      expected: [`"block-1"`],
-    },
-    {
-      description: '@theme block',
-      configured: [{ type: '@theme' }],
-      expected: [`"block-1"`, `"block-2"`, `"custom-block"`],
-    },
-    {
-      description: '@app block',
-      configured: [{ type: '@app' }],
-      expected: [],
-    },
-    {
-      description: 'no blocks',
-      configured: [],
-      expected: [],
-    },
-  ];
-
-  describe('top-level preset blocks', () => {
-    for (const test of tests) {
-      it(`completes preset block type when allowed ${test.description}`, async () => {
-        const source = `
-          {% schema %}
-          {
-            "blocks": ${JSON.stringify(test.configured)},
-            "presets": [{
-              "blocks": [
-                { "type": "█" },
-              ]
-            }]
-          }
-          {% endschema %}
-        `;
-
-        const params = getRequestParams(documentManager, 'sections/section.liquid', source);
-        const completions = await jsonLanguageService.completions(params);
-
-        assert(isCompletionList(completions));
-        expect(completions.items).to.have.lengthOf(test.expected.length);
-        expect(completions.items.map((item) => item.label)).to.include.members(test.expected);
-      });
-    }
-  });
-
-  describe('nested preset blocks', () => {
-    for (const test of tests) {
-      it(`completes preset block type when parent block allows ${test.description}`, async () => {
-        const source = `
-          {% schema %}
-          {
-            "blocks": [{"type": "custom-block"}],
-            "presets": [{
-              "blocks": [
-                {
-                  "type": "custom-block",
-                  "blocks": [{"type": "█"}],
-                },
-              ]
-            }]
-          }
-          {% endschema %}
-        `;
-
-        documentManager.open(
-          `${rootUri}/blocks/custom-block.liquid`,
-          `{% schema %}
-            {
-              "blocks": ${JSON.stringify(test.configured)}
-            }
-          {% endschema %}`,
-          1,
-        );
-
-        const params = getRequestParams(documentManager, 'sections/section.liquid', source);
-        const completions = await jsonLanguageService.completions(params);
-
-        assert(isCompletionList(completions));
-        expect(completions.items).to.have.lengthOf(test.expected.length);
-        expect(completions.items.map((item) => item.label)).to.include.members(test.expected);
-      });
-    }
-  });
-});

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

@@ -1,120 +0,0 @@
-import { deepGet, isError } from '@platformos/platformos-check-common';
-import { JSONPath } from 'vscode-json-languageservice';
-import { JSONCompletionItem } from 'vscode-json-languageservice/lib/umd/jsonContributions';
-import { isLiquidRequestContext, RequestContext } from '../../RequestContext';
-import { isSectionOrBlockFile } from '../../utils';
-import { JSONCompletionProvider } from '../JSONCompletionProvider';
-import {
-  createBlockNameCompletionItems,
-  isSectionOrBlockSchema,
-} from './BlockTypeCompletionProvider';
-import { GetThemeBlockNames, GetThemeBlockSchema } from '../../JSONContributions';
-
-/**
- * The ReferencedBlockTypeCompletionProvider offers value completions of the
- * `presets.[](recursive .blocks.[]).type` value and `default.blocks.[].type` value inside
- * section and theme block `{% schema %}` tags.
- *
- * @example
- * {% schema %}
- * {
- *   "presets": [
- *     {
- *       "blocks": [
- *         { "type": "█" },
- *       ]
- *     },
- *   ],
- *   "default": {
- *     "blocks": [
- *       { "type": "█" },
- *     ]
- *   }
- * }
- * {% endschema %}
- */
-export class ReferencedBlockTypeCompletionProvider implements JSONCompletionProvider {
-  constructor(
-    private getThemeBlockNames: GetThemeBlockNames,
-    private getThemeBlockSchema: GetThemeBlockSchema,
-  ) {}
-
-  async completeValue(context: RequestContext, path: JSONPath): Promise<JSONCompletionItem[]> {
-    if (
-      !isSectionOrBlockFile(context.doc.uri) ||
-      !isLiquidRequestContext(context) ||
-      !isBlockTypePath(path)
-    ) {
-      return [];
-    }
-
-    const { doc } = context;
-    const schema = await doc.getSchema();
-
-    if (!schema || isError(schema.parsed) || !isSectionOrBlockSchema(schema)) {
-      return [];
-    }
-
-    let parsedBlockSchema = schema.parsed;
-
-    if (isNestedBlockPath(path)) {
-      const parentBlockName = getParentBlockName(schema.parsed, path);
-      if (!parentBlockName) {
-        return [];
-      }
-
-      const parentBlockSchema = await this.getThemeBlockSchema(doc.uri, parentBlockName);
-
-      if (
-        !parentBlockSchema ||
-        isError(parentBlockSchema.parsed) ||
-        !isSectionOrBlockSchema(parentBlockSchema)
-      ) {
-        return [];
-      }
-
-      parsedBlockSchema = parentBlockSchema.parsed;
-    }
-
-    const blocks: { type: string }[] = parsedBlockSchema.blocks || [];
-
-    const blockGroups = {
-      themeBlocks: false,
-      specificBlockNames: [] as string[],
-    };
-
-    blocks.forEach((block) => {
-      if (block.type === '@theme') {
-        blockGroups.themeBlocks = true;
-      } else if (!block.type.startsWith('@')) {
-        blockGroups.specificBlockNames.push(block.type);
-      }
-    });
-
-    let blockNames = blockGroups.specificBlockNames;
-
-    if (blockGroups.themeBlocks) {
-      blockNames.push(...(await this.getThemeBlockNames(doc.uri, false)));
-    }
-
-    return createBlockNameCompletionItems(blockNames);
-  }
-}
-
-// `blocks` can be nested within other `blocks`
-// We need to ensure the last leg of the path is { "blocks": [{ "type": "█" }] }
-function isBlockTypePath(path: JSONPath) {
-  return (
-    (path.at(0) === 'presets' || path.at(0) === 'default') &&
-    path.at(-3) === 'blocks' &&
-    path.at(-1) === 'type'
-  );
-}
-
-function isNestedBlockPath(path: JSONPath) {
-  return path.at(-5) === 'blocks' && path.at(-3) === 'blocks' && path.at(-1) === 'type';
-}
-
-function getParentBlockName(parsedSchema: any, path: JSONPath) {
-  return deepGet(parsedSchema, [...path.slice(0, -3), 'type']);
-}

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

@@ -1,51 +0,0 @@
-import { deepGet } from '@platformos/platformos-check-common';
-import { CompletionItemKind, JSONPath } from 'vscode-json-languageservice';
-import {
-  GetTranslationsForURI,
-  renderTranslation,
-  translationOptions,
-} from '../../../translations';
-import { isLiquidRequestContext, RequestContext } from '../../RequestContext';
-import { isSectionOrBlockFile } from '../../utils';
-import { JSONCompletionItem, JSONCompletionProvider } from '../JSONCompletionProvider';
-
-export class SchemaTranslationsCompletionProvider implements JSONCompletionProvider {
-  constructor(private getDefaultSchemaTranslations: GetTranslationsForURI) {}
-
-  async completeValue(context: RequestContext, path: JSONPath): Promise<JSONCompletionItem[]> {
-    if (!isSectionOrBlockFile(context.doc.uri) || !isLiquidRequestContext(context)) {
-      return [];
-    }
-
-    const { doc, parsed } = context;
-
-    const label = deepGet(parsed, path);
-    if (!label || typeof label !== 'string' || !label.startsWith('t:')) {
-      return [];
-    }
-
-    const partial = /^t:(.*)/.exec(label)?.[1];
-    if (partial === undefined) return [];
-
-    const translations = await this.getDefaultSchemaTranslations(doc.uri);
-
-    // We'll let the frontend do the filtering. But we'll only include shopify
-    // translations if the shopify prefix is present
-    const options = translationOptions(translations);
-
-    return options.map((option): JSONCompletionItem => {
-      const tLabel = `t:${option.path.join('.')}`;
-      return {
-        label: tLabel,
-        kind: CompletionItemKind.Value,
-        filterText: `"${tLabel}"`,
-        insertText: `"${tLabel}"`,
-        insertTextFormat: 1,
-        documentation: {
-          kind: 'markdown',
-          value: renderTranslation(option.translation),
-        },
-      };
-    });
-  }
-}