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

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

@@ -1,321 +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: SectionRenameHandler', () => {
-  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(
-      {
-        'sections/old-name.liquid': `
-            {% schema %}
-              {
-                "name": "Old name"
-              }
-            {% endschema %}`,
-
-        'layout/theme.liquid': `
-            {% section 'old-name' %}
-          `,
-
-        'sections/header.json': `
-            {
-              "type": "header",
-              "name": "Header",
-              "sections": {
-                "section-id": {
-                  "type": "old-name"
-                }
-              },
-              "order": ["section-id"]
-            }`,
-
-        'templates/index.json': `
-            {
-              "sections": {
-                "section-id": {
-                  "type": "old-name"
-                }
-              },
-              "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:/sections/old-name.liquid',
-            newUri: 'mock-fs:/sections/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 section', async () => {
-      await handler.onDidRenameFiles({
-        files: [
-          {
-            oldUri: 'mock-fs:/sections/old-name.liquid',
-            newUri: 'mock-fs:/sections/new-name.liquid',
-          },
-        ],
-      });
-
-      const replaceWithNewNameTextEditAtAnyLocation = {
-        annotationId: 'renameSection',
-        newText: 'new-name',
-        range: {
-          start: expect.any(Object),
-          end: expect.any(Object),
-        },
-      };
-
-      const templateTextEdits = [
-        // Section type is updated in the section sections array
-        replaceWithNewNameTextEditAtAnyLocation,
-      ];
-
-      const sectionGroupTextEdits = [
-        // Section type is updated in the section sections array,
-        replaceWithNewNameTextEditAtAnyLocation,
-      ];
-
-      const sectionTagTextEdits = [
-        // Over {% section 'old-name' %}
-        replaceWithNewNameTextEditAtAnyLocation,
-      ];
-
-      expect(connection.spies.sendRequest).toHaveBeenCalledWith('workspace/applyEdit', {
-        label: "Rename section 'old-name' to 'new-name'",
-        edit: {
-          changeAnnotations: {
-            renameSection: {
-              label: `Rename section 'old-name' to 'new-name'`,
-              needsConfirmation: false,
-            },
-          },
-          documentChanges: expect.arrayContaining([
-            {
-              textDocument: {
-                uri: 'mock-fs:/layout/theme.liquid',
-                version: null,
-              },
-              edits: sectionTagTextEdits,
-            },
-            {
-              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:/sections/old-name.liquid',
-            newUri: 'mock-fs:/sections/new-name.liquid',
-          },
-        ],
-      });
-
-      const params: ApplyWorkspaceEditParams = connection.spies.sendRequest.mock.calls[0][1];
-      const expectedFs = new MockFileSystem(
-        {
-          'sections/new-name.liquid': `
-            {% schema %}
-              {
-                "name": "Old name"
-              }
-            {% endschema %}`,
-
-          'layout/theme.liquid': `
-            {% section 'new-name' %}
-          `,
-
-          'sections/header.json': `
-            {
-              "type": "header",
-              "name": "Header",
-              "sections": {
-                "section-id": {
-                  "type": "new-name"
-                }
-              },
-              "order": ["section-id"]
-            }`,
-
-          'templates/index.json': `
-            {
-              "sections": {
-                "section-id": {
-                  "type": "new-name"
-                }
-              },
-              "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 section definitions', async () => {
-      fs = new MockFileSystem(
-        {
-          // a "theme" text section exists
-          'sections/text.liquid': `
-            {% schema %}
-              { "name": "text section" }
-            {% endschema %}`,
-
-          // this section uses a local section of type "text"
-          'sections/local.liquid': `
-            {% schema %}
-              {
-                "name": "Section with local sections",
-                "sections": [
-                  {
-                    "type": "text",
-                    "name": "Local text section"
-                  }
-                ],
-                "presets": [
-                  {
-                    "name": "Because text is a local section definition, this preset won't get a rename",
-                    "sections": [
-                      { "type": "text" }
-                    ]
-                  }
-                ]
-              }
-            {% endschema %}`,
-
-          // This section group uses the local section that uses the local section, no rename needed
-          'sections/header.json': JSON.stringify({
-            type: 'header',
-            name: 'Header',
-            sections: {
-              local_id: {
-                type: 'local',
-                sections: {
-                  text_tqQTNE: {
-                    type: 'text',
-                  },
-                },
-                section_order: ['text_tqQTNE'],
-              },
-            },
-            order: ['local_id'],
-          }),
-
-          // This template uses the section that uses the local section, no rename needed
-          'templates/index.json': JSON.stringify({
-            sections: {
-              local: {
-                type: 'local',
-                sections: {
-                  text_tqQTNE: {
-                    type: 'text',
-                  },
-                },
-                section_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:/sections/text.liquid',
-            newUri: 'mock-fs:/sections/poetry.liquid',
-          },
-        ],
-      });
-
-      // Check if sendRequest was called at all
-      expect(connection.spies.sendRequest).not.toHaveBeenCalled();
-    });
-  });
-});

package/src/renamed/handlers/SectionRenameHandler.ts

@@ -1,224 +0,0 @@
-import { LiquidString } from '@platformos/liquid-html-parser';
-import {
-  isError,
-  LiteralNode,
-  nodeAtPath,
-  parseJSON,
-  path,
-  SourceCodeType,
-  visit,
-} from '@platformos/platformos-check-common';
-import { Connection } from 'vscode-languageserver';
-import {
-  AnnotatedTextEdit,
-  ApplyWorkspaceEditRequest,
-  Range,
-  RenameFilesParams,
-  TextDocumentEdit,
-  AnnotatedTextEdit as TextEdit,
-  WorkspaceEdit,
-} from 'vscode-languageserver-protocol';
-import { ClientCapabilities } from '../../ClientCapabilities';
-import {
-  AugmentedJsonSourceCode,
-  AugmentedLiquidSourceCode,
-  AugmentedSourceCode,
-  DocumentManager,
-  isJsonSourceCode,
-  isLiquidSourceCode,
-} from '../../documents';
-import { FindThemeRootURI } from '../../internal-types';
-import { isSection, isSectionGroup, isTemplate, sectionName } from '../../utils/uri';
-import { BaseRenameHandler } from '../BaseRenameHandler';
-import { isValidSectionGroup, isValidTemplate } from './utils';
-
-type DocumentChange = TextDocumentEdit;
-
-const annotationId = 'renameSection';
-
-/**
- * The SectionRenameHandler will handle section renames
- *
- * Whenever a section gets renamed, a lot of things need to happen:
- *   2. References in template files must be changed
- *   3. References in section groups must be changed
- *   4. References like {% section "oldName" %} must be changed
- */
-export class SectionRenameHandler implements BaseRenameHandler {
-  constructor(
-    private documentManager: DocumentManager,
-    private connection: Connection,
-    private capabilities: ClientCapabilities,
-    private findThemeRootURI: FindThemeRootURI,
-  ) {}
-
-  async onDidRenameFiles(params: RenameFilesParams): Promise<void> {
-    if (!this.capabilities.hasApplyEditSupport) return;
-
-    const relevantRenames = params.files.filter(
-      (file) => isSection(file.oldUri) && isSection(file.newUri),
-    );
-
-    // Only preload if you have something to do (folder renames not supported yet).
-    if (relevantRenames.length !== 1) return;
-    const rename = relevantRenames[0];
-    const rootUri = await this.findThemeRootURI(path.dirname(params.files[0].oldUri));
-    if (!rootUri) return;
-    await this.documentManager.preload(rootUri);
-    const theme = this.documentManager.theme(rootUri, true);
-    const liquidFiles = theme.filter(isLiquidSourceCode);
-    const templates = theme.filter(isJsonSourceCode).filter((file) => isTemplate(file.uri));
-    const sectionGroups = theme.filter(isJsonSourceCode).filter((file) => isSectionGroup(file.uri));
-    const oldSectionName = sectionName(rename.oldUri);
-    const newSectionName = sectionName(rename.newUri);
-    const editLabel = `Rename section '${oldSectionName}' to '${newSectionName}'`;
-    const workspaceEdit: WorkspaceEdit = {
-      documentChanges: [],
-      changeAnnotations: {
-        [annotationId]: {
-          label: editLabel,
-          needsConfirmation: false,
-        },
-      },
-    };
-
-    // All the templates/*.json files need to be updated with the new block name
-    // when the old block name wasn't a local block.
-    const [templateChanges, sectionGroupChanges, sectionTagChanges] = await Promise.all([
-      Promise.all(templates.map(this.getTemplateChanges(oldSectionName, newSectionName))),
-      Promise.all(sectionGroups.map(this.getSectionGroupChanges(oldSectionName, newSectionName))),
-      Promise.all(liquidFiles.map(this.getSectionTagChanges(oldSectionName, newSectionName))),
-    ]);
-
-    for (const docChange of [...templateChanges, ...sectionGroupChanges]) {
-      if (docChange !== null) {
-        workspaceEdit.documentChanges!.push(docChange);
-      }
-    }
-
-    // Because section tag changes could make a change to an existing document,
-    // we need to group the edits together by document. Or else we might have
-    // index drifting issues.
-    for (const docChange of sectionTagChanges) {
-      if (docChange !== null) {
-        const existingDocChange = (workspaceEdit.documentChanges as DocumentChange[]).find(
-          (dc) => dc.textDocument.uri === docChange?.textDocument.uri,
-        );
-        if (existingDocChange) {
-          existingDocChange.edits.push(...docChange.edits);
-        } else {
-          workspaceEdit.documentChanges!.push(docChange);
-        }
-      }
-    }
-
-    if (workspaceEdit.documentChanges!.length === 0) {
-      console.error('Nothing to do!');
-      return;
-    }
-
-    await this.connection.sendRequest(ApplyWorkspaceEditRequest.type, {
-      label: editLabel,
-      edit: workspaceEdit,
-    });
-  }
-
-  private getTemplateChanges(oldSectionName: string, newSectionName: string) {
-    return async (sourceCode: AugmentedJsonSourceCode) => {
-      const { textDocument, ast, source } = sourceCode;
-      const parsed = parseJSON(source);
-      if (!parsed || isError(parsed) || isError(ast)) return null;
-      const edits: AnnotatedTextEdit[] = !isValidTemplate(parsed)
-        ? []
-        : Object.entries(parsed.sections)
-            .filter(([_key, section]) => section.type === oldSectionName)
-            .map(([key]) => {
-              const node = nodeAtPath(ast, ['sections', key, 'type']) as LiteralNode;
-              return {
-                annotationId,
-                newText: newSectionName,
-                range: Range.create(
-                  textDocument.positionAt(node.loc.start.offset + 1),
-                  textDocument.positionAt(node.loc.end.offset - 1),
-                ),
-              } as AnnotatedTextEdit;
-            });
-
-      if (edits.length === 0) return null;
-
-      return documentChanges(sourceCode, edits);
-    };
-  }
-
-  // Awfully similar except for the isValidSectionGroup check and the types of the objects.
-  // Feels like a coincidence that the types are so similar. I'm not sure this should be DRY'd up.
-  private getSectionGroupChanges(oldSectionName: string, newSectionName: string) {
-    return async (sourceCode: AugmentedJsonSourceCode) => {
-      const { textDocument, ast, source } = sourceCode;
-      const parsed = parseJSON(source);
-      if (!parsed || isError(parsed) || isError(ast)) return null;
-      const edits: TextEdit[] = !isValidSectionGroup(parsed)
-        ? []
-        : Object.entries(parsed.sections)
-            .filter(([_key, section]) => section.type === oldSectionName)
-            .map(([key]) => {
-              const node = nodeAtPath(ast, ['sections', key, 'type']) as LiteralNode;
-              return {
-                annotationId,
-                newText: newSectionName,
-                range: Range.create(
-                  textDocument.positionAt(node.loc.start.offset + 1),
-                  textDocument.positionAt(node.loc.end.offset - 1),
-                ),
-              } as AnnotatedTextEdit;
-            });
-
-      if (edits.length === 0) return null;
-
-      return documentChanges(sourceCode, edits);
-    };
-  }
-
-  private getSectionTagChanges(oldSectionName: string, newSectionName: string) {
-    return async (sourceCode: AugmentedLiquidSourceCode) => {
-      const { textDocument, ast } = sourceCode;
-      if (isError(ast)) return null;
-
-      const edits = await visit<SourceCodeType.LiquidHtml, TextEdit>(ast, {
-        async LiquidTag(node) {
-          if (node.name !== 'section') return;
-          if (typeof node.markup === 'string') return;
-
-          // Note the type assertion to the LHS of the expression.
-          // The type assertions above are enough for this to be true.
-          // But I'm making the explicit annotation here to make it clear.
-          const typeNode: LiquidString = node.markup;
-          if (typeNode.value !== oldSectionName) return;
-
-          return {
-            annotationId,
-            newText: newSectionName,
-            range: Range.create(
-              textDocument.positionAt(typeNode.position.start + 1),
-              textDocument.positionAt(typeNode.position.end - 1),
-            ),
-          };
-        },
-      });
-
-      if (edits.length === 0) return null;
-
-      return documentChanges(sourceCode, edits);
-    };
-  }
-}
-
-function documentChanges(sourceCode: AugmentedSourceCode, edits: TextEdit[]): DocumentChange {
-  return {
-    textDocument: {
-      uri: sourceCode.uri,
-      version: sourceCode.version ?? null /* null means file from disk in this API */,
-    },
-    edits,
-  };
-}

package/src/renamed/handlers/utils.ts

@@ -1,22 +0,0 @@
-import { Template } from '@platformos/platformos-check-common';
-
-// this is very very optimistic...
-export function isValidTemplate(parsed: unknown): parsed is Template.Template {
-  return (
-    typeof parsed === 'object' &&
-    parsed !== null &&
-    'sections' in parsed &&
-    'order' in parsed &&
-    Array.isArray((parsed as Template.Template).order)
-  );
-}
-
-export function isValidSectionGroup(parsed: unknown): parsed is Template.SectionGroup {
-  return (
-    typeof parsed === 'object' &&
-    parsed !== null &&
-    'sections' in parsed &&
-    'order' in parsed &&
-    Array.isArray((parsed as Template.SectionGroup).order)
-  );
-}

package/src/settings/index.ts

@@ -1,50 +0,0 @@
-export type GetThemeSettingsSchemaForURI = (uri: string) => Promise<SettingsSchemaJSONFile>;
-
-export type SettingsSchemaJSONFile = (ThemeInfo | SettingsCategory)[];
-
-export interface ThemeInfo {
-  name: string;
-  theme_name: string;
-  theme_author: string;
-  theme_version: string;
-  theme_documentation_url: string;
-  theme_support_url?: string;
-  theme_support_email?: string;
-}
-
-export interface SettingsCategory {
-  name: string;
-  settings: Setting[];
-}
-
-export type Setting = SideBarSetting | InputSetting;
-
-export interface SideBarSetting {
-  type: string;
-  content: string;
-}
-
-export interface InputSetting {
-  type: string;
-  id: string;
-  label: string;
-  default?: number | string | boolean | string[];
-  info?: string;
-}
-
-interface Option {
-  label: string;
-  value: string;
-}
-
-interface MaybeGroupedOption extends Option {
-  group?: string;
-}
-
-export function isSettingsCategory(x: ThemeInfo | SettingsCategory): x is SettingsCategory {
-  return 'settings' in x;
-}
-
-export function isInputSetting(x: Setting): x is InputSetting {
-  return 'id' in x && 'type' in x && 'label' in x;
-}