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

package/src/json/schemaSettings.spec.ts

@@ -1,103 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { getSectionBlockByName, schemaSettingsPropertyCompletionItems } from './schemaSettings';
-
-describe('Unit: schemaSettings', () => {
-  const translations = {
-    title: 'Example Title',
-  };
-
-  describe('schemaSettingsPropertyCompletionItems', () => {
-    it('returns completion item if setting has a valid id', () => {
-      const completions = schemaSettingsPropertyCompletionItems(
-        [
-          {
-            id: 'setting-id',
-            label: 'Setting Label',
-          },
-        ],
-        translations,
-      );
-
-      expect(completions).to.have.lengthOf(1);
-      expect(completions).toContainEqual(
-        expect.objectContaining({
-          insertText: '"setting-id"',
-          documentation: expect.objectContaining({
-            value: 'Setting Label',
-          }),
-        }),
-      );
-    });
-
-    it('returns translated completion item', () => {
-      const completions = schemaSettingsPropertyCompletionItems(
-        [
-          {
-            id: 'setting-id',
-            label: 't:title',
-          },
-        ],
-
-        translations,
-      );
-
-      expect(completions).to.have.lengthOf(1);
-      expect(completions).toContainEqual(
-        expect.objectContaining({
-          insertText: '"setting-id"',
-          documentation: expect.objectContaining({
-            value: 'Example Title',
-          }),
-        }),
-      );
-    });
-
-    it("does not return completion item if setting doesn't have id", () => {
-      const completions = schemaSettingsPropertyCompletionItems(
-        [
-          {
-            label: 'Setting Label',
-          },
-        ],
-        translations,
-      );
-      expect(completions).to.have.lengthOf(0);
-    });
-  });
-
-  describe('getSectionBlockByName', () => {
-    it('does not return block if parsedSchema is empty', () => {
-      expect(getSectionBlockByName(undefined, 'block-name')).toBeUndefined();
-    });
-
-    it('does not return block if it is not a section block is empty', () => {
-      expect(
-        getSectionBlockByName(
-          {
-            blocks: [
-              {
-                type: 'block-name',
-              },
-            ],
-          },
-          'block-name',
-        ),
-      ).toBeUndefined();
-    });
-
-    it('does return block if it is a section block is empty', () => {
-      const block = {
-        type: 'block-name',
-        name: 'block name',
-      };
-      expect(
-        getSectionBlockByName(
-          {
-            blocks: [block],
-          },
-          'block-name',
-        ),
-      ).toBe(block);
-    });
-  });
-});

package/src/json/schemaSettings.ts

@@ -1,53 +0,0 @@
-import { CompletionItemKind, MarkupKind } from 'vscode-json-languageservice';
-import { renderTranslation, translationValue } from '../translations';
-import { Section, Setting, Translations } from '@platformos/platformos-check-common';
-import { JSONCompletionItem } from './completions/JSONCompletionProvider';
-
-export function schemaSettingsPropertyCompletionItems(
-  parsedSettings: Partial<Setting.Any>[],
-  translations: Translations,
-): JSONCompletionItem[] {
-  return parsedSettings
-    .filter((setting) => setting.id)
-    .map((setting) => {
-      let docValue = '';
-
-      if (setting.label) {
-        if (setting.label.startsWith('t:')) {
-          const translation = translationValue(setting.label.substring(2), translations);
-
-          if (translation) {
-            docValue = renderTranslation(translation);
-          }
-        } else {
-          docValue = setting.label;
-        }
-      }
-
-      const completionText = setting.id ? `"${setting.id}"` : '';
-
-      return {
-        kind: CompletionItemKind.Property,
-        label: completionText,
-        insertText: completionText,
-        documentation: {
-          kind: MarkupKind.Markdown,
-          value: docValue,
-        },
-      };
-    });
-}
-
-/*
- * JSONCompletionProviders have to be more fault tolerant since there can be errors
- * while typing the schema. This is why parsedSchemas (untyped) are used instead of
- * validSchemas (typed).
- */
-export function getSectionBlockByName(
-  parsedSchema: any = {},
-  blockName: string,
-): Partial<Section.LocalBlock> | undefined {
-  return parsedSchema.blocks
-    ?.filter((block: any) => 'name' in block)
-    ?.find((block: any) => block.type === blockName);
-}

package/src/plugins/css.ts

@@ -1,12 +0,0 @@
-import { getCSSLanguageService, LanguageService } from 'vscode-css-languageservice';
-
-const cssLanguageService = getCSSLanguageService();
-
-const languageServices = {
-  css: cssLanguageService,
-};
-export type CSSLanguageServices = Record<'css' | 'less' | 'scss', LanguageService>;
-
-export function getCssLanguageService(kind: 'css'): LanguageService {
-  return languageServices[kind];
-}

package/src/renamed/handlers/BlockRenameHandler.spec.ts

@@ -1,399 +0,0 @@
-import { MockFileSystem } from '@platformos/platformos-check-common/src/test';
-import { assert, beforeEach, describe, expect, it } from 'vitest';
-import { TextDocumentEdit } from 'vscode-json-languageservice';
-import { ApplyWorkspaceEditParams } from 'vscode-languageserver-protocol';
-import { ClientCapabilities } from '../../ClientCapabilities';
-import { DocumentManager } from '../../documents';
-import { MockConnection, mockConnection } from '../../test/MockConnection';
-import { RenameHandler } from '../RenameHandler';
-
-describe('Module: BlockRenameHandler', () => {
-  const mockRoot = 'mock-fs:';
-  const findThemeRootURI = async () => mockRoot;
-  let capabilities: ClientCapabilities;
-  let documentManager: DocumentManager;
-  let handler: RenameHandler;
-  let connection: MockConnection;
-  let fs: MockFileSystem;
-
-  beforeEach(() => {
-    connection = mockConnection(mockRoot);
-    connection.spies.sendRequest.mockReturnValue(Promise.resolve(true));
-    capabilities = new ClientCapabilities();
-    fs = new MockFileSystem(
-      {
-        'blocks/other-block.liquid': ``,
-        'blocks/old-name.liquid': `
-            {% schema %}
-              {
-                "name": "Old Block",
-                "blocks": [{ "type": "other-block" }],
-                "presets": [{
-                  "name": "Default",
-                  "blocks": [{
-                    "type": "other-block"
-                  }]
-                }]
-              }
-            {% endschema %}`,
-
-        'sections/section.liquid': `
-            <div>{% content_for "block", id: "old-name-id", type: "old-name" %}</div>
-            {% schema %}
-              {
-                "name": "Section",
-                "blocks": [{ "type": "old-name" }],
-                "presets": [
-                  {
-                    "name": "Default",
-                    "blocks": [
-                      {
-                        "type": "old-name",
-                        "blocks": [{ "type": "other-block" }]
-                      }
-                    ]
-                  }
-                ]
-              }
-            {% endschema %}`,
-
-        'sections/header.json': `
-            {
-              "type": "header",
-              "name": "Header",
-              "sections": {
-                "section-id": {
-                  "type": "section",
-                  "blocks": {
-                    "old-name-id": {
-                      "type": "old-name"
-                    }
-                  },
-                  "block_order": ["old-name-id"]
-                }
-              },
-              "order": ["section-id"]
-            }`,
-
-        'templates/index.json': `
-            {
-              "sections": {
-                "section-id": {
-                  "type": "section",
-                  "blocks": {
-                    "old-name-id": {
-                      "type": "old-name"
-                    }
-                  },
-                  "block_order": ["old-name-id"]
-                }
-              },
-              "order": ["section-id"]
-            }`,
-      },
-      mockRoot,
-    );
-    documentManager = new DocumentManager(
-      fs, // filesystem
-      undefined, // optional mode getter
-      undefined, // optional mode map
-      async () => 'theme', // getModeForURI
-      async () => true, // isValidSchema - assume all schemas are valid in tests
-    );
-    handler = new RenameHandler(connection, capabilities, documentManager, findThemeRootURI);
-  });
-
-  describe('when the client does not support workspace/applyEdit', () => {
-    beforeEach(() => {
-      capabilities.setup({
-        workspace: {
-          applyEdit: false,
-        },
-      });
-    });
-
-    it('does nothing', async () => {
-      await handler.onDidRenameFiles({
-        files: [
-          {
-            oldUri: 'mock-fs:/blocks/old-name.liquid',
-            newUri: 'mock-fs:/blocks/new-name.liquid',
-          },
-        ],
-      });
-      expect(connection.spies.sendRequest).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('when the client supports workspace/applyEdit', () => {
-    beforeEach(() => {
-      capabilities.setup({
-        workspace: {
-          applyEdit: true,
-        },
-      });
-    });
-
-    it('returns a needConfirmation: false workspace edit for renaming a block', async () => {
-      await handler.onDidRenameFiles({
-        files: [
-          {
-            oldUri: 'mock-fs:/blocks/old-name.liquid',
-            newUri: 'mock-fs:/blocks/new-name.liquid',
-          },
-        ],
-      });
-
-      const replaceWithNewNameTextEditAtAnyLocation = {
-        annotationId: 'renameBlock',
-        newText: 'new-name',
-        range: {
-          start: expect.any(Object),
-          end: expect.any(Object),
-        },
-      };
-
-      const templateTextEdits = [
-        // Block type is updated in the section blocks array
-        replaceWithNewNameTextEditAtAnyLocation,
-      ];
-
-      const sectionGroupTextEdits = [
-        // Block type is updated in the section blocks array,
-        replaceWithNewNameTextEditAtAnyLocation,
-      ];
-
-      const sectionFileTextEdits = [
-        // In the content_for
-        replaceWithNewNameTextEditAtAnyLocation,
-        // In the blocks definition
-        replaceWithNewNameTextEditAtAnyLocation,
-        // In the presets
-        replaceWithNewNameTextEditAtAnyLocation,
-      ];
-
-      expect(connection.spies.sendRequest).toHaveBeenCalledWith('workspace/applyEdit', {
-        label: "Rename block 'old-name' to 'new-name'",
-        edit: {
-          changeAnnotations: {
-            renameBlock: {
-              label: `Rename block 'old-name' to 'new-name'`,
-              needsConfirmation: false,
-            },
-          },
-          documentChanges: expect.arrayContaining([
-            {
-              textDocument: {
-                uri: 'mock-fs:/sections/section.liquid',
-                version: null,
-              },
-              edits: sectionFileTextEdits,
-            },
-            {
-              textDocument: {
-                uri: 'mock-fs:/templates/index.json',
-                version: null,
-              },
-              edits: templateTextEdits,
-            },
-            {
-              textDocument: {
-                uri: 'mock-fs:/sections/header.json',
-                version: null,
-              },
-              edits: sectionGroupTextEdits,
-            },
-          ]),
-        },
-      });
-    });
-
-    it('replaces the correct text in the documents', async () => {
-      await handler.onDidRenameFiles({
-        files: [
-          {
-            oldUri: 'mock-fs:/blocks/old-name.liquid',
-            newUri: 'mock-fs:/blocks/new-name.liquid',
-          },
-        ],
-      });
-
-      const params: ApplyWorkspaceEditParams = connection.spies.sendRequest.mock.calls[0][1];
-      const expectedFs = new MockFileSystem(
-        {
-          'blocks/new-name.liquid': `
-            {% schema %}
-              {
-                "name": "Old Block",
-                "blocks": [{ "type": "other-block" }],
-                "presets": [{
-                  "name": "Default",
-                  "blocks": [{
-                    "type": "other-block"
-                  }]
-                }]
-              }
-            {% endschema %}`,
-
-          // The old-name block type is updated, but not the id.
-          'sections/section.liquid': `
-            <div>{% content_for "block", id: "old-name-id", type: "new-name" %}</div>
-            {% schema %}
-              {
-                "name": "Section",
-                "blocks": [{ "type": "new-name" }],
-                "presets": [
-                  {
-                    "name": "Default",
-                    "blocks": [
-                      {
-                        "type": "new-name",
-                        "blocks": [{ "type": "other-block" }]
-                      }
-                    ]
-                  }
-                ]
-              }
-            {% endschema %}`,
-
-          'sections/header.json': `
-            {
-              "type": "header",
-              "name": "Header",
-              "sections": {
-                "section-id": {
-                  "type": "section",
-                  "blocks": {
-                    "old-name-id": {
-                      "type": "new-name"
-                    }
-                  },
-                  "block_order": ["old-name-id"]
-                }
-              },
-              "order": ["section-id"]
-            }`,
-
-          // The old-name-id's block type is updated, but not the id.
-          // This isn't a regex search and replace.
-          'templates/index.json': `
-            {
-              "sections": {
-                "section-id": {
-                  "type": "section",
-                  "blocks": {
-                    "old-name-id": {
-                      "type": "new-name"
-                    }
-                  },
-                  "block_order": ["old-name-id"]
-                }
-              },
-              "order": ["section-id"]
-            }`,
-        },
-        mockRoot,
-      );
-
-      assert(params.edit);
-      assert(params.edit.documentChanges);
-
-      for (const docChange of params.edit.documentChanges) {
-        assert(TextDocumentEdit.is(docChange));
-        const uri = docChange.textDocument.uri;
-        const edits = docChange.edits;
-        const initialDoc = await fs.readFile(uri);
-        const expectedDoc = await expectedFs.readFile(uri);
-        expect(edits).to.applyEdits(initialDoc, expectedDoc);
-      }
-    });
-
-    it('preserves local block definitions', async () => {
-      fs = new MockFileSystem(
-        {
-          // a "theme" text block exists
-          'blocks/text.liquid': `
-            {% schema %}
-              { "name": "text block" }
-            {% endschema %}`,
-
-          // this section uses a local block of type "text"
-          'sections/local.liquid': `
-            {% schema %}
-              {
-                "name": "Section with local blocks",
-                "blocks": [
-                  {
-                    "type": "text",
-                    "name": "Local text block"
-                  }
-                ],
-                "presets": [
-                  {
-                    "name": "Because text is a local block definition, this preset won't get a rename",
-                    "blocks": [
-                      { "type": "text" }
-                    ]
-                  }
-                ]
-              }
-            {% endschema %}`,
-
-          // This section group uses the local section that uses the local block, no rename needed
-          'sections/header.json': JSON.stringify({
-            type: 'header',
-            name: 'Header',
-            sections: {
-              local_id: {
-                type: 'local',
-                blocks: {
-                  text_tqQTNE: {
-                    type: 'text',
-                  },
-                },
-                block_order: ['text_tqQTNE'],
-              },
-            },
-            order: ['local_id'],
-          }),
-
-          // This template uses the section that uses the local block, no rename needed
-          'templates/index.json': JSON.stringify({
-            sections: {
-              local: {
-                type: 'local',
-                blocks: {
-                  text_tqQTNE: {
-                    type: 'text',
-                  },
-                },
-                block_order: ['text_tqQTNE'],
-              },
-            },
-          }),
-        },
-        mockRoot,
-      );
-      documentManager = new DocumentManager(
-        fs,
-        undefined,
-        undefined,
-        async () => 'theme',
-        async () => true,
-      );
-      handler = new RenameHandler(connection, capabilities, documentManager, findThemeRootURI);
-
-      await handler.onDidRenameFiles({
-        files: [
-          {
-            oldUri: 'mock-fs:/blocks/text.liquid',
-            newUri: 'mock-fs:/blocks/poetry.liquid',
-          },
-        ],
-      });
-
-      // Check if sendRequest was called at all
-      expect(connection.spies.sendRequest).not.toHaveBeenCalled();
-    });
-  });
-});