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

package/src/types.ts

@@ -1,7 +1,4 @@
-import {
-  Config,
-  Dependencies as ThemeCheckDependencies,
-} from '@platformos/platformos-check-common';
+import { Config, Dependencies as CheckDependencies } from '@platformos/platformos-check-common';
 import { AbstractFileSystem } from '@platformos/platformos-common';
 import { URI } from 'vscode-languageserver';
 import * as rpc from 'vscode-jsonrpc';
@@ -10,10 +7,7 @@ import { WithOptional } from './utils';
 import { Range } from 'vscode-json-languageservice';
 import { Reference } from '@platformos/platformos-graph';
 
-export type Dependencies = WithOptional<
-  RequiredDependencies,
-  'log' | 'getMetafieldDefinitions' | 'fetchMetafieldDefinitionsForURI'
->;
+export type Dependencies = WithOptional<RequiredDependencies, 'log'>;
 
 export interface RequiredDependencies {
   /**
@@ -34,25 +28,25 @@ export interface RequiredDependencies {
    *
    * @example
    *
-   * Here's an example VS Code workspace a partner could run
+   * Here's an example VS Code workspace a developer could run
    * ```
-   * theme1/
-   *   src/
-   *     locales/
-   *     sections/
-   *     snippets/
-   *   dist/
-   *     locales/
-   *     sections/
-   *       foo.liquud
-   *     snippets/
-   * theme2/
-   *   locales/
-   *   sections/
-   *   snippets/
+   * my-app/
+   *   .pos
+   *   app/
+   *     views/
+   *       layouts/
+   *       pages/
+   *       partials/
+   *     lib/
+   *     assets/
+   * another-app/
+   *   .pos
+   *   app/
+   *     views/
+   *       pages/
    * ```
    *
-   * In this situation, we have 3 different "roots."
+   * In this situation, we have 2 different "roots."
    *
    * @param uri - a file path
    * @returns {Promise<Config>}
@@ -61,19 +55,17 @@ export interface RequiredDependencies {
 
   /**
    * In local environments, the Language Server can download the latest versions
-   * of themes docset from `Shopify/theme-liquid-docs`. However, this is not
-   * possible in the browser, so we implement different solutions for each
-   * environment.
+   * of the platformOS Liquid docset. In the browser, the docset must be
+   * precompiled into the bundle at build time.
    */
-  themeDocset: NonNullable<ThemeCheckDependencies['themeDocset']>;
+  platformosDocset: NonNullable<CheckDependencies['platformosDocset']>;
 
   /**
-   * In local environments, the Language Server can download the latest versions
-   * of themes schemas from `Shopify/theme-liquid-docs`. Due to limitations in
-   * browser environments, json schemas must be precompiled into validators prior
-   * to theme-check instantiation.
+   * In local environments, the Language Server can download the latest JSON
+   * validation schemas. In browser environments, schemas must be precompiled
+   * into validators prior to platformos-check instantiation.
    */
-  jsonValidationSet: NonNullable<ThemeCheckDependencies['jsonValidationSet']>;
+  jsonValidationSet: NonNullable<CheckDependencies['jsonValidationSet']>;
 
   /**
    * A file system abstraction that allows the Language Server to read files by URI.
@@ -85,23 +77,10 @@ export interface RequiredDependencies {
    * The browser accepts a custom implementation.
    */
   fs: AbstractFileSystem;
-
-  /**
-   * In local environments, the Language Server can download the metafield definitions
-   * and provide a set of memoized definitions. In other environments, we rely on dynamically
-   * fetching the set of metafield definitions every time.
-   */
-  getMetafieldDefinitions: ThemeCheckDependencies['getMetafieldDefinitions'];
-
-  /**
-   * Fetch Metafield definitions using the CLI provided the URI of the project root.
-   * This should only be used in node environments; not on the browser.
-   */
-  fetchMetafieldDefinitionsForURI: (uri: URI) => Promise<void>;
 }
 
-export namespace ThemeGraphReferenceRequest {
-  export const method = 'themeGraph/references';
+export namespace AppGraphReferenceRequest {
+  export const method = 'appGraph/references';
   export const type = new rpc.RequestType<Params, Response, void>(method);
   export interface Params {
     uri: string;
@@ -111,8 +90,8 @@ export namespace ThemeGraphReferenceRequest {
   export type Response = AugmentedReference[];
 }
 
-export namespace ThemeGraphDependenciesRequest {
-  export const method = 'themeGraph/dependencies';
+export namespace AppGraphDependenciesRequest {
+  export const method = 'appGraph/dependencies';
   export const type = new rpc.RequestType<Params, Response, void>(method);
   export interface Params {
     uri: string;
@@ -122,8 +101,8 @@ export namespace ThemeGraphDependenciesRequest {
   export type Response = AugmentedReference[];
 }
 
-export namespace ThemeGraphRootRequest {
-  export const method = 'themeGraph/rootUri';
+export namespace AppGraphRootRequest {
+  export const method = 'appGraph/rootUri';
   export const type = new rpc.RequestType<Params, Response, void>(method);
   export interface Params {
     uri: string;
@@ -131,17 +110,8 @@ export namespace ThemeGraphRootRequest {
   export type Response = string;
 }
 
-export namespace ThemeGraphDeadCodeRequest {
-  export const method = 'themeGraph/deadCode';
-  export const type = new rpc.RequestType<Params, Response, void>(method);
-  export interface Params {
-    uri: string;
-  }
-  export type Response = string[];
-}
-
-export namespace ThemeGraphDidUpdateNotification {
-  export const method = 'themeGraph/onDidChangeTree';
+export namespace AppGraphDidUpdateNotification {
+  export const method = 'appGraph/onDidChangeTree';
   export const type = new rpc.NotificationType<Params>(method);
   export interface Params {
     uri: string;

package/src/utils/debounce.ts

@@ -27,7 +27,7 @@ export interface DebouncedFunction<F extends Function> {
  * This is useful in cases where you have an "expensive" function that you only want
  * to execute after the user is idle for a little bit.
  *
- * e.g. Run theme check after the user has stopped typing for at least 100ms.
+ * e.g. Run platformos-check after the user has stopped typing for at least 100ms.
  *
  * The debounced function has the same type signature as its argument.
  *

package/src/utils/liquidDoc.ts

@@ -29,11 +29,11 @@ export function formatLiquidDocTagHandle(label: string, description: string, exa
 export const SUPPORTED_LIQUID_DOC_TAG_HANDLES = {
   [SupportedDocTagTypes.Param]: {
     description:
-      'Provides information about a parameter for the snippet.\n' +
+      'Provides information about a parameter for the partial.\n' +
       `- The type of parameter is optional and can be ${Object.values(BasicParamTypes)
         .map((type) => `\`${type}\``)
         .join(', ')}\n` +
-      ` or liquid object that isn't exclusively a global object in our [API Docs](https://shopify.dev/docs/api/liquid/objects)\n` +
+      ` or liquid object that isn't exclusively a global object in our [API Docs](https://documentation.platformos.com/api-reference/liquid/platformos-objects)\n` +
       '- An optional parameter is denoted by square brackets around the parameter name\n' +
       '- The description is optional Markdown text',
     example:
@@ -45,15 +45,15 @@ export const SUPPORTED_LIQUID_DOC_TAG_HANDLES = {
     template: `param {$2} $1$0`,
   },
   [SupportedDocTagTypes.Example]: {
-    description: 'Provides an example on how to use the snippet.',
+    description: 'Provides an example on how to use the partial.',
     example:
-      '{% doc %}\n' + '  @example {% render "snippet-name", arg1: "value" %}\n' + '{% enddoc %}\n',
+      '{% doc %}\n' + '  @example {% render "partial-name", arg1: "value" %}\n' + '{% enddoc %}\n',
     template: `example $0`,
   },
   [SupportedDocTagTypes.Description]: {
-    description: 'Provides information on what the snippet does.',
+    description: 'Provides information on what the partial does.',
     example:
-      '{% doc %}\n' + '  @description This snippet renders a product image.\n' + '{% enddoc %}\n',
+      '{% doc %}\n' + '  @description This partial renders a product image.\n' + '{% enddoc %}\n',
     template: `description $0`,
   },
 };

package/src/utils/uri.ts

@@ -1,22 +1,10 @@
 import { path } from '@platformos/platformos-check-common';
+import { isPartial, PlatformOSFileType, getFileType } from '@platformos/platformos-common';
+
+export { isPartial };
 
 export const partialName = (uri: string) => path.basename(uri, '.liquid');
-export const isPartial = (uri: string) => /\b(partials|lib)(\\|\/)[^\\\/]*\.liquid/.test(uri);
 
-// asset urls have their `.liquid`` removed (if present) and require the other extension */
+// asset urls have their `.liquid` removed (if present) and require the other extension
 export const assetName = (uri: string) => path.basename(uri, '.liquid');
-export const isAsset = (uri: string) => /\bassets(\\|\/)[^\\\/]/.test(uri);
-
-export const blockName = (uri: string) => path.basename(uri, '.liquid');
-export const isBlock = (uri: string) => /\bblocks(\\|\/)[^\\\/]/.test(uri);
-
-export const sectionName = (uri: string) => path.basename(uri, '.liquid');
-export const isSection = (uri: string) =>
-  /\bsections(\\|\/)[^\\\/]/.test(uri) && /.liquid$/.test(uri);
-
-export const sectionGroupName = (uri: string) => path.basename(uri, '.json');
-export const isSectionGroup = (uri: string) =>
-  /\bsections(\\|\/)[^\\\/]/.test(uri) && /.json$/.test(uri);
-
-export const templateName = (uri: string) => path.basename(uri, '.json');
-export const isTemplate = (uri: string) => /\btemplates(\\|\/)[^\\\/]/.test(uri);
+export const isAsset = (uri: string) => getFileType(uri) === PlatformOSFileType.Asset;

package/src/completions/providers/ContentForBlockTypeCompletionProvider.spec.ts

@@ -1,41 +0,0 @@
-import { MetafieldDefinitionMap } from '@platformos/platformos-check-common';
-import { beforeEach, describe, expect, it } from 'vitest';
-import { InsertTextFormat } from 'vscode-json-languageservice';
-import { DocumentManager } from '../../documents';
-import { CompletionsProvider } from '../CompletionsProvider';
-
-describe('Module: ContentForBlockTypeCompletionProvider', async () => {
-  let provider: CompletionsProvider;
-
-  beforeEach(async () => {
-    provider = new CompletionsProvider({
-      documentManager: new DocumentManager(),
-      themeDocset: {
-        graphQL: async () => null,
-        filters: async () => [],
-        objects: async () => [],
-        liquidDrops: async () => [],
-        tags: async () => [],
-        systemTranslations: async () => ({}),
-      },
-      getMetafieldDefinitions: async (_rootUri: string) => ({}) as MetafieldDefinitionMap,
-      getThemeBlockNames: async (_rootUri: string, _includePrivate: boolean) => [
-        'block-1',
-        'block-2',
-      ],
-    });
-  });
-
-  it('should complete content_for "block" type parameter ', async () => {
-    const expected = ['block-1', 'block-2'].sort();
-    await expect(provider).to.complete('{% content_for "block", type: "█" %}', expected);
-  });
-
-  it('should not complete content_for "blocks" type parameter', async () => {
-    await expect(provider).to.complete('{% content_for "blocks", type: "█" %}', []);
-  });
-
-  it('should not complete content_for "block" id parameter', async () => {
-    await expect(provider).to.complete('{% content_for "block", type: "", id: "█" %}', []);
-  });
-});

package/src/completions/providers/ContentForBlockTypeCompletionProvider.ts

@@ -1,42 +0,0 @@
-import { NodeTypes } from '@platformos/liquid-html-parser';
-import { CompletionItem, CompletionItemKind } from 'vscode-languageserver';
-import { LiquidCompletionParams } from '../params';
-import { Provider } from './common';
-
-export class ContentForBlockTypeCompletionProvider implements Provider {
-  constructor(
-    private readonly getThemeBlockNames: (
-      rootUri: string,
-      includePrivate: boolean,
-    ) => Promise<string[]>,
-  ) {}
-
-  async completions(params: LiquidCompletionParams): Promise<CompletionItem[]> {
-    if (!params.completionContext) return [];
-
-    const { document } = params;
-    const doc = document.textDocument;
-    const { node, ancestors } = params.completionContext;
-    const parentNode = ancestors.at(-1);
-    const grandParentNode = ancestors.at(-2);
-
-    if (
-      !node ||
-      !parentNode ||
-      !grandParentNode ||
-      node.type !== NodeTypes.String ||
-      parentNode.type !== NodeTypes.NamedArgument ||
-      parentNode.name !== 'type' ||
-      grandParentNode.type !== NodeTypes.ContentForMarkup ||
-      grandParentNode.contentForType.value !== 'block'
-    ) {
-      return [];
-    }
-
-    return (await this.getThemeBlockNames(doc.uri, false)).map((blockName) => ({
-      label: blockName,
-      kind: CompletionItemKind.EnumMember,
-      insertText: blockName,
-    }));
-  }
-}

package/src/completions/providers/ContentForCompletionProvider.spec.ts

@@ -1,96 +0,0 @@
-import { MetafieldDefinitionMap } from '@platformos/platformos-check-common';
-import { beforeEach, describe, expect, it } from 'vitest';
-import { InsertTextFormat } from 'vscode-json-languageservice';
-import { DocumentManager } from '../../documents';
-import { CompletionsProvider } from '../CompletionsProvider';
-
-describe('Module: ContentForCompletionProvider', async () => {
-  let provider: CompletionsProvider;
-
-  beforeEach(async () => {
-    provider = new CompletionsProvider({
-      documentManager: new DocumentManager(),
-      themeDocset: {
-        graphQL: async () => null,
-        filters: async () => [],
-        objects: async () => [],
-        liquidDrops: async () => [],
-        tags: async () => [],
-        systemTranslations: async () => ({}),
-      },
-      getMetafieldDefinitions: async (_rootUri: string) => ({}) as MetafieldDefinitionMap,
-    });
-  });
-
-  it('should complete content_for block keywords correctly', async () => {
-    const expected = ['block', 'blocks'].sort();
-    await expect(provider).to.complete('{% content_for "█" %}', expected);
-  });
-
-  describe('when the text being completed does not have extra markup', () => {
-    it('should text edit complete content_for block with type & id placeholders', async () => {
-      const source = '{% content_for "█" %}';
-      await expect(provider).to.complete(
-        source,
-        expect.arrayContaining([
-          expect.objectContaining({
-            label: 'block',
-            textEdit: expect.applyEdits(source, `{% content_for "block", type: "$1", id: "$2" %}`),
-          }),
-        ]),
-      );
-    });
-
-    it('should keep using the quote type used', async () => {
-      const source = `{% content_for '█' %}`;
-      await expect(provider).to.complete(
-        source,
-        expect.arrayContaining([
-          expect.objectContaining({
-            label: 'block',
-            textEdit: expect.applyEdits(
-              source,
-              // single quotes everywhere
-              `{% content_for 'block', type: '$1', id: '$2' %}`,
-            ),
-          }),
-        ]),
-      );
-    });
-
-    it('should text edit complete inside the liquid liquid tag', async () => {
-      const source = `{% liquid
-        content_for "█"
-        echo "more content"
-      %}`;
-      const afterEdit = `{% liquid
-        content_for "block", type: "$1", id: "$2"
-        echo "more content"
-      %}`;
-      await expect(provider).to.complete(
-        source,
-        expect.arrayContaining([
-          expect.objectContaining({
-            label: 'block',
-            textEdit: expect.applyEdits(source, afterEdit),
-          }),
-        ]),
-      );
-    });
-  });
-
-  describe('when it has extra markup', () => {
-    it('should not text edit complete', async () => {
-      const source = '{% content_for "█", type: "some-type", id: "some-id" %}';
-      await expect(provider).to.complete(
-        source,
-        expect.arrayContaining([
-          expect.objectContaining({
-            label: 'block',
-            insertTextFormat: InsertTextFormat.PlainText,
-          }),
-        ]),
-      );
-    });
-  });
-});

package/src/completions/providers/ContentForCompletionProvider.ts

@@ -1,113 +0,0 @@
-import { LiquidString, NodeTypes } from '@platformos/liquid-html-parser';
-import {
-  CompletionItem,
-  CompletionItemKind,
-  InsertTextFormat,
-  Range,
-  TextEdit,
-} from 'vscode-languageserver';
-import { LiquidCompletionParams } from '../params';
-import { Provider } from './common';
-
-export class ContentForCompletionProvider implements Provider {
-  constructor() {}
-
-  async completions(params: LiquidCompletionParams): Promise<CompletionItem[]> {
-    if (!params.completionContext) return [];
-
-    const { document } = params;
-    const doc = document.textDocument;
-    const { node, ancestors } = params.completionContext;
-    const parentNode = ancestors.at(-1);
-
-    if (
-      !node ||
-      !parentNode ||
-      node.type !== NodeTypes.String ||
-      parentNode.type !== NodeTypes.ContentForMarkup
-    ) {
-      return [];
-    }
-
-    const options = [
-      {
-        keyword: 'block',
-        description: 'Renders a static theme block within `sections` or `theme blocks`.\n',
-        syntax: "content_for 'block', type: '$1', id: '$2'",
-      },
-      {
-        keyword: 'blocks',
-        description: `Renders block elements within sections or other blocks as configured in the JSON template or section groups.
-See [theme blocks](https://shopify.dev/docs/storefronts/themes/architecture/blocks/theme-blocks)
-to see how to create theme blocks that can be used this way.\n`,
-        syntax: `content_for 'blocks'`,
-      },
-    ];
-
-    const partial = node.value;
-    const isInLiquidLiquidTag = ancestors.some(
-      (node) => node.type === NodeTypes.LiquidTag && node.name === 'liquid',
-    );
-    const startPosition = node.position.start + 1; // after the quote
-    const endPosition = indexOf(
-      document.source,
-      // We want to maintain trailing whitespace to whatever it was before the completion
-      isInLiquidLiquidTag ? / *\n/g : /\s*-?%}/gm,
-      startPosition + partial.length,
-    );
-    const hasMarkup =
-      document.source
-        .slice(startPosition + partial.length, endPosition)
-        .replace(/^['"]/, '')
-        .trim() !== '';
-    const shouldCompleteSyntax = endPosition !== -1 && !hasMarkup;
-
-    return options
-      .filter(({ keyword }) => keyword.startsWith(partial))
-      .map(({ keyword, description, syntax }): CompletionItem => {
-        const item: CompletionItem = {
-          label: keyword,
-          kind: CompletionItemKind.Keyword,
-          insertTextFormat: InsertTextFormat.PlainText,
-          documentation: {
-            kind: 'markdown',
-            value: description,
-          },
-        };
-
-        if (shouldCompleteSyntax) {
-          const snippetText = getSnippetText(node, syntax);
-          item.insertTextFormat = InsertTextFormat.Snippet;
-          item.textEdit = TextEdit.replace(
-            Range.create(doc.positionAt(startPosition), doc.positionAt(endPosition)),
-            snippetText,
-          );
-        }
-
-        return item;
-      });
-  }
-}
-
-function getSnippetText(node: LiquidString, syntax: string): string {
-  // Language clients don't like it when the text edit starts before the word being completed
-  // So we make the snippet text start with the word being completed
-  return (
-    syntax
-      .replace(/^content_for '/, '')
-      // use the same quote type as the original string everywhere in the snippet
-      .replace(node.single ? /"/g : /'/g, node.single ? "'" : '"')
-  );
-}
-
-/**
- * String.prototype.indexOf does not accept RegExp args...
- * String.prototype.search does not accept fromIndex args...
- *
- * We want both.
- */
-function indexOf(string: string, searchValue: RegExp, fromIndex: number): number {
-  searchValue.lastIndex = fromIndex;
-  const match = searchValue.exec(string);
-  return match ? match.index : -1;
-}