@platformos/platformos-language-server-common 0.0.2

package/src/documents/DocumentManager.spec.ts

@@ -0,0 +1,276 @@
+import {
+  path,
+  Section,
+  Setting,
+  ThemeBlock,
+  ThemeSchemaType,
+} from '@platformos/platformos-check-common';
+import { AbstractFileSystem } from '@platformos/platformos-common';
+import { MockFileSystem } from '@platformos/platformos-check-common/src/test';
+import { assert, beforeEach, describe, expect, it, vi } from 'vitest';
+import { URI, Utils } from 'vscode-uri';
+import { DocumentManager } from './DocumentManager';
+import { mockConnection } from '../test/MockConnection';
+import { ClientCapabilities } from '../ClientCapabilities';
+
+describe('Module: DocumentManager', () => {
+  const mockRoot = 'mock-fs:';
+  let documentManager: DocumentManager;
+  let connection: ReturnType<typeof mockConnection>;
+  let fs: AbstractFileSystem;
+
+  beforeEach(() => {
+    documentManager = new DocumentManager();
+  });
+
+  it('should return a theme for a root', () => {
+    // these will be different in windows vs unix
+    const rootUri = URI.file(__dirname);
+    const fileUri = Utils.joinPath(rootUri, 'test.liquid');
+
+    // We expect forward slash paths (windows path get normalized)
+    expect(fileUri.path).not.to.include('\\');
+    documentManager.open(fileUri.toString(), '{{ "hi" }}', 0);
+    const theme = documentManager.theme(path.normalize(rootUri));
+    expect(theme).to.have.lengthOf(1);
+    expect(theme[0].uri).not.to.include('\\');
+    // `fileURI.toString()` lowercases c: in 'C:\dir\path'
+    // Without the URI.parse().path, this test was failing for a dumb reason
+    expect(theme[0].uri).to.equal(path.normalize(fileUri));
+  });
+
+  describe('when initialized with an abstract file system', () => {
+    beforeEach(async () => {
+      fs = new MockFileSystem(
+        {
+          'snippet/foo.liquid': `hello {% render 'bar' %}`,
+          'snippet/bar.liquid': `world`,
+        },
+        'mock-fs:',
+      );
+      documentManager = new DocumentManager(fs);
+      vi.spyOn(fs, 'readFile');
+    });
+
+    describe('when the abstract file system is preloaded', () => {
+      beforeEach(async () => {
+        await documentManager.preload('mock-fs:/');
+      });
+
+      it('preloads source codes with a version of undefined', async () => {
+        const sc = documentManager.get('mock-fs:/snippet/foo.liquid');
+        assert(sc);
+        expect(sc.version).to.equal(undefined);
+      });
+
+      it('returns defined versions of opened files', () => {
+        documentManager.open('mock-fs:/snippet/foo.liquid', 'hello {% render "bar" %}', 0);
+        const sc = documentManager.get('mock-fs:/snippet/foo.liquid');
+        assert(sc);
+        expect(sc.version).to.equal(0);
+      });
+
+      describe('Unit: theme(rootUri, includeFilesFromDisk)', () => {
+        it('only returns the source codes of the opened files by default', () => {
+          const theme = documentManager.theme('mock-fs:/');
+          expect(theme).to.have.lengthOf(0);
+        });
+
+        it('returns all the files when called with includeFilesFromDisk', async () => {
+          const theme = documentManager.theme('mock-fs:/', true);
+          expect(theme).to.have.lengthOf(2);
+        });
+      });
+
+      describe('Unit: close(uri)', () => {
+        it('sets the source version to undefined (value is on disk)', () => {
+          documentManager.open('mock-fs:/snippet/foo.liquid', 'hello {% render "bar" %}', 10);
+          documentManager.close('mock-fs:/snippet/foo.liquid');
+          const sc = documentManager.get('mock-fs:/snippet/foo.liquid');
+          assert(sc);
+          expect(sc.source).to.equal('hello {% render "bar" %}');
+          expect(sc.version).to.equal(undefined);
+        });
+      });
+
+      describe('Unit: delete(uri)', () => {
+        it('deletes the source code from the document manager', () => {
+          // as though the file no longer exists
+          documentManager.open('mock-fs:/snippet/foo.liquid', 'hello {% render "bar" %}', 10);
+          documentManager.delete('mock-fs:/snippet/foo.liquid');
+          const sc = documentManager.get('mock-fs:/snippet/foo.liquid');
+          assert(!sc);
+        });
+      });
+
+      describe('Unit: preload(rootUri)', () => {
+        it('should be memoized and only run once', async () => {
+          await documentManager.preload('mock-fs:/');
+          await documentManager.preload('mock-fs:/');
+          await documentManager.preload('mock-fs:/');
+          await documentManager.preload('mock-fs:/');
+          expect(vi.mocked(fs.readFile)).toHaveBeenCalledTimes(
+            documentManager.theme('mock-fs:/', true).length,
+          );
+        });
+      });
+    });
+  });
+
+  describe('when initialized with a connection & hasProgressSupport', () => {
+    beforeEach(() => {
+      const capabilities = new ClientCapabilities();
+      capabilities.setup({
+        window: {
+          workDoneProgress: true,
+        },
+      });
+      connection = mockConnection(mockRoot);
+      connection.spies.onRequest.mockImplementationOnce(async (method) => {
+        switch (method) {
+          case 'window/workDoneProgress/create':
+            return 'ok';
+          default:
+            throw new Error(`Unexpected method: ${method}`);
+        }
+      });
+
+      fs = new MockFileSystem(
+        {
+          'snippet/1.liquid': `hello {% render 'bar' %}`,
+          'snippet/2.liquid': `hello {% render 'bar' %}`,
+          'snippet/3.liquid': `hello {% render 'bar' %}`,
+          'snippet/4.liquid': `hello {% render 'bar' %}`,
+          'snippet/5.liquid': `hello {% render 'bar' %}`,
+          'snippet/6.liquid': `hello {% render 'bar' %}`,
+          'snippet/7.liquid': `hello {% render 'bar' %}`,
+          'snippet/8.liquid': `hello {% render 'bar' %}`,
+          'snippet/9.liquid': `hello {% render 'bar' %}`,
+          'snippet/10.liquid': `hello {% render 'bar' %}`,
+        },
+        mockRoot,
+      );
+      vi.spyOn(fs, 'readFile');
+
+      documentManager = new DocumentManager(fs, connection, capabilities);
+    });
+
+    it('should report progress while preloading', async () => {
+      await documentManager.preload(mockRoot);
+      expect(connection.spies.sendProgress).toHaveBeenCalledTimes(4);
+      expect(connection.spies.sendProgress).toHaveBeenCalledWith(
+        expect.anything(),
+        'preload#mock-fs:',
+        {
+          kind: 'begin',
+          title: 'Initializing Liquid LSP',
+        },
+      );
+      expect(connection.spies.sendProgress).toHaveBeenCalledWith(
+        expect.anything(),
+        'preload#mock-fs:',
+        {
+          kind: 'report',
+          message: 'Preloading files',
+          percentage: 10,
+        },
+      );
+      expect(connection.spies.sendProgress).toHaveBeenCalledWith(
+        expect.anything(),
+        'preload#mock-fs:',
+        {
+          kind: 'report',
+          message: 'Preloading files [10/10]',
+          percentage: 100,
+        },
+      );
+      expect(connection.spies.sendProgress).toHaveBeenCalledWith(
+        expect.anything(),
+        'preload#mock-fs:',
+        {
+          kind: 'end',
+          message: 'Completed',
+        },
+      );
+    });
+  });
+
+  describe('when initialized with a fs, getModeForURI, and isValidSchema', () => {
+    const mockFsRoot = path.normalize('mock-fs:/theme');
+    const sectionSchema: Section.Schema = {
+      name: 'hello',
+      settings: [{ type: 'number' as Setting.Type.Number, id: 'my_num' }],
+      default: { settings: { my_num: 1 } },
+    };
+    const blockSchema: ThemeBlock.Schema = {
+      name: 'world',
+      blocks: [{ type: '@theme' }],
+    };
+
+    beforeEach(async () => {
+      fs = new MockFileSystem(
+        {
+          'sections/foo.liquid': `
+             {% schema %}
+               ${JSON.stringify(sectionSchema, null, 2)}
+             {% endschema %}`,
+          'blocks/bar.liquid': `
+            {% schema %}
+              ${JSON.stringify(blockSchema, null, 2)}
+            {% endschema %}`,
+        },
+        mockFsRoot,
+      );
+      documentManager = new DocumentManager(
+        fs,
+        undefined,
+        undefined,
+        async () => 'theme',
+        async () => true, // let's assume they are valid for testing purposes...
+      );
+      await documentManager.preload(mockFsRoot);
+    });
+
+    it('should augment section files with a getSchema property that resolves to a type-safe schema', async () => {
+      const section = documentManager.get(path.join(mockFsRoot, 'sections/foo.liquid'));
+      assert(section);
+      assert(section.type === 'LiquidHtml');
+      const schema = await section.getSchema();
+      assert(schema);
+      assert(schema.type === ThemeSchemaType.Section);
+      expect(schema.parsed).to.eql(sectionSchema);
+      const validSchema = schema.validSchema;
+      assert(!(validSchema instanceof Error));
+
+      // Note below that validSchema.name is accessed in a type-safe manner
+      expect(validSchema.name).to.equal(sectionSchema.name);
+      assert(validSchema.settings);
+      for (const setting of validSchema.settings) {
+        assert(setting.type);
+        assert(setting.id);
+      }
+
+      // Default is a section-only property
+      assert(validSchema.default);
+    });
+
+    it('should augment block files with a getSchema property that resolves to a type-safe schema', async () => {
+      const block = documentManager.get(path.join(mockFsRoot, 'blocks/bar.liquid'));
+      assert(block);
+      assert(block.type === 'LiquidHtml');
+      const schema = await block.getSchema();
+      assert(schema);
+      assert(schema.type === ThemeSchemaType.Block);
+      expect(schema.parsed).to.eql(blockSchema);
+      const validSchema = schema.validSchema;
+      assert(!(validSchema instanceof Error));
+
+      // Note below that validSchema.name is accessed in a type-safe manner
+      expect(validSchema.name).to.equal(blockSchema.name);
+      assert(validSchema.blocks);
+      for (const block of validSchema.blocks) {
+        assert(block.type);
+      }
+    });
+  });
+});

package/src/documents/DocumentManager.ts

@@ -0,0 +1,232 @@
+import {
+  assertNever,
+  memoize,
+  path,
+  recursiveReadDirectory,
+  SourceCodeType,
+  Theme,
+  toSourceCode,
+  toSchema,
+  UriString,
+  IsValidSchema,
+  memo,
+  Mode,
+  isError,
+} from '@platformos/platformos-check-common';
+
+import { AbstractFileSystem } from '@platformos/platformos-common';
+import { Connection } from 'vscode-languageserver';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { ClientCapabilities } from '../ClientCapabilities';
+import { percent, Progress } from '../progress';
+import { AugmentedSourceCode } from './types';
+import { extractDocDefinition } from '@platformos/platformos-check-common';
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+export class DocumentManager {
+  /**
+   * The sourceCodes map is a map of URIs to SourceCodes. It is used to keep
+   * track of all the open documents in the workspace as well as caching the ASTs
+   * of the documents.
+   *
+   * Files that are opened in the editor have a defined version, while files that
+   * are preloaded have a version of `undefined`.
+   */
+  private sourceCodes: Map<UriString, AugmentedSourceCode>;
+  private recentlyRenamed: Set<UriString>;
+
+  constructor(
+    private readonly fs?: AbstractFileSystem,
+    private readonly connection?: Connection,
+    private readonly clientCapabilities?: ClientCapabilities,
+    private readonly getModeForUri?: (uri: UriString) => Promise<Mode>,
+    private readonly isValidSchema?: IsValidSchema,
+  ) {
+    this.sourceCodes = new Map();
+    this.recentlyRenamed = new Set();
+  }
+
+  public open(uri: UriString, source: string, version: number | undefined) {
+    return this.set(uri, source, version);
+  }
+
+  public change(uri: UriString, source: string, version: number | undefined) {
+    return this.set(uri, source, version);
+  }
+
+  public async changeFromDisk(uri: UriString) {
+    if (!this.fs) throw new Error('Cannot call changeFromDisk without a FileSystem');
+    this.change(uri, await this.fs.readFile(uri), undefined);
+  }
+
+  public close(uri: UriString) {
+    const sourceCode = this.sourceCodes.get(uri);
+    if (!sourceCode) return;
+    return this.set(uri, sourceCode.source, undefined);
+  }
+
+  public delete(uri: UriString) {
+    return this.sourceCodes.delete(uri);
+  }
+
+  public rename(oldUri: UriString, newUri: UriString) {
+    this.trackRename(oldUri, newUri);
+    const sourceCode = this.sourceCodes.get(oldUri);
+    if (!sourceCode) return;
+    this.sourceCodes.delete(oldUri);
+    this.set(newUri, sourceCode.source, sourceCode.version);
+  }
+
+  public theme(root: UriString, includeFilesFromDisk = false): AugmentedSourceCode[] {
+    return [...this.sourceCodes.values()]
+      .filter((sourceCode) => sourceCode.uri.startsWith(root))
+      .filter(
+        (sourceCode) => includeFilesFromDisk || sourceCode.version !== undefined,
+      ) satisfies Theme;
+  }
+
+  public get openDocuments(): AugmentedSourceCode[] {
+    return [...this.sourceCodes.values()].filter((sourceCode) => sourceCode.version !== undefined);
+  }
+
+  public get(uri: UriString) {
+    return this.sourceCodes.get(path.normalize(uri));
+  }
+
+  public has(uri: UriString) {
+    return this.sourceCodes.has(path.normalize(uri));
+  }
+
+  /** Used to prevent cache busting twice for the same operation */
+  public hasRecentRename(uri: UriString) {
+    return this.recentlyRenamed.has(uri);
+  }
+
+  public clearRecentRename(uri: UriString) {
+    this.recentlyRenamed.delete(uri);
+  }
+
+  private set(uri: UriString, source: string, version: number | undefined) {
+    uri = path.normalize(uri);
+    // We only support json and liquid files.
+    if (!/\.(json|liquid|graphql)$/.test(uri) || /\.(s?css|js).liquid$/.test(uri)) {
+      return;
+    }
+
+    this.sourceCodes.set(uri, this.augmentedSourceCode(uri, source, version));
+  }
+
+  /**
+   * The preload method is used to pre-load and pre-parse all the files in the
+   * theme. It is smart and only will load files that are not already in the
+   * DocumentManager.
+   *
+   * Files that are loaded from the AbstractFileSystem will have a version of `undefined`.
+   */
+  public preload = memoize(
+    async (rootUri: UriString) => {
+      if (!this.fs) throw new Error('Cannot call preload without a FileSystem');
+      const { fs, connection, clientCapabilities } = this;
+      const progress = Progress.create(connection, clientCapabilities, `preload#${rootUri}`);
+
+      progress.start('Initializing Liquid LSP');
+
+      // We'll only load the files that aren't already in the store. No need to
+      // parse a file we already parsed.
+      const filesToLoad = await recursiveReadDirectory(
+        this.fs,
+        rootUri,
+        ([uri]) => /\.(liquid|json|graphql)$/.test(uri) && !this.sourceCodes.has(uri),
+      );
+
+      progress.report(10, 'Preloading files');
+
+      let [i, n] = [0, filesToLoad.length];
+      await Promise.all(
+        filesToLoad.map(async (file) => {
+          // This is what is important, we are loading the file from the file system
+          // And setting their initial version to `undefined` to mean "on disk".
+          try {
+            this.set(file, await fs.readFile(file), undefined);
+          } catch (error) {
+            console.error('Failed to preload', file, error);
+          }
+
+          // This is just doing progress reporting
+          if (++i % 10 === 0) {
+            const message = `Preloading files [${i}/${n}]`;
+            progress.report(percent(i, n, 10), message);
+          }
+        }),
+      );
+      progress.end('Completed');
+    },
+    (rootUri) => rootUri,
+  );
+
+  private augmentedSourceCode(
+    uri: UriString,
+    source: string,
+    version: number | undefined,
+  ): AugmentedSourceCode {
+    const sourceCode = toSourceCode(uri, source, version);
+    const textDocument = TextDocument.create(
+      uri,
+      sourceCode.type,
+      sourceCode.version ?? 0, // create doesn't let us put undefined here.
+      sourceCode.source,
+    );
+
+    switch (sourceCode.type) {
+      case SourceCodeType.JSON:
+        return {
+          ...sourceCode,
+          textDocument,
+        };
+      case SourceCodeType.GraphQL:
+        return {
+          ...sourceCode,
+          textDocument,
+        };
+      case SourceCodeType.LiquidHtml:
+        return {
+          ...sourceCode,
+          textDocument,
+          /** Lazy and only computed once per file version */
+          getSchema: memo(async () => {
+            if (!this.getModeForUri || !this.isValidSchema) return undefined;
+
+            const mode = await this.getModeForUri!(uri);
+            return toSchema(mode, uri, sourceCode, this.isValidSchema, false);
+          }),
+          /** Lazy and only computed once per file version */
+          getLiquidDoc: memo(async () => {
+            const ast = sourceCode.ast;
+            if (isError(ast)) return undefined;
+
+            return extractDocDefinition(uri, ast);
+          }),
+        };
+      default:
+        return assertNever(sourceCode);
+    }
+  }
+
+  /**
+   * The workspace/onDidRenameFile notification is sent when a file is renamed in the workspace (via a user gesture)
+   * The workspace/onDidChangeWatchedFiles notification is sent when a file is renamed on disk (via a file system event)
+   *
+   * The order is not guaranteed, but it seems to be true that onDidRenameFile happens before onDidChangeWatchedFiles.
+   *
+   * In the off-chance that the order is reversed, we'll have the sleep timer to clean up the state.
+   */
+  private trackRename(oldUri: UriString, newUri: UriString) {
+    this.recentlyRenamed.add(oldUri);
+    this.recentlyRenamed.add(newUri);
+    sleep(2000).then(() => {
+      this.clearRecentRename(oldUri);
+      this.clearRecentRename(newUri);
+    });
+  }
+}

package/src/documents/index.ts

@@ -0,0 +1,2 @@
+export { DocumentManager } from './DocumentManager';
+export * from './types';

package/src/documents/types.ts

@@ -0,0 +1,55 @@
+import {
+  SourceCodeType,
+  SourceCode,
+  SectionSchema,
+  ThemeBlockSchema,
+  AppBlockSchema,
+} from '@platformos/platformos-check-common';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { DocDefinition } from '@platformos/platformos-check-common';
+
+/** Util type to add the common `textDocument` property to the SourceCode. */
+type _AugmentedSourceCode<SCT extends SourceCodeType = SourceCodeType> = SourceCode<SCT> & {
+  textDocument: TextDocument;
+};
+
+/** JsonSourceCode + textDocument */
+export type AugmentedJsonSourceCode = _AugmentedSourceCode<SourceCodeType.JSON>;
+
+export type AugmentedGraphQLSourceCode = _AugmentedSourceCode<SourceCodeType.GraphQL>;
+
+/**
+ * AugmentedLiquidSourceCode may hold the schema for the section or block.
+ *
+ * We'll use the SourceCode as the source of truth since we won't need to care
+ * about cache invalidation and will mean we'll parse the schema at most once.
+ */
+export type AugmentedLiquidSourceCode = _AugmentedSourceCode<SourceCodeType.LiquidHtml> & {
+  getSchema: () => Promise<SectionSchema | ThemeBlockSchema | AppBlockSchema | undefined>;
+  getLiquidDoc: () => Promise<DocDefinition | undefined>;
+};
+
+/**
+ * AugmentedSourceCode is a union of the two augmented source codes.
+ *
+ * When passed a specific SourceCodeType, it will return the correct AugmentedSourceCode.
+ *
+ * @example
+ * AugmentedSourceCode -> AugmentedJsonSourceCode | AugmentedLiquidSourceCode
+ * AugmentedSourceCode<SourceCodeType.JSON> -> AugmentedJsonSourceCode
+ * AugmentedSourceCode<SourceCodeType.LiquidHtml> -> AugmentedLiquidSourceCode
+ */
+export type AugmentedSourceCode<SCT extends SourceCodeType = SourceCodeType> = {
+  [SourceCodeType.JSON]: AugmentedJsonSourceCode;
+  [SourceCodeType.LiquidHtml]: AugmentedLiquidSourceCode;
+  [SourceCodeType.GraphQL]: AugmentedGraphQLSourceCode;
+}[SCT];
+
+export const isLiquidSourceCode = (file: AugmentedSourceCode): file is AugmentedLiquidSourceCode =>
+  file.type === SourceCodeType.LiquidHtml;
+
+export const isJsonSourceCode = (file: AugmentedSourceCode): file is AugmentedJsonSourceCode =>
+  file.type === SourceCodeType.JSON;
+
+export const isGraphQLSourceceCode = (file: AugmentedSourceCode): file is AugmentedJsonSourceCode =>
+  file.type === SourceCodeType.GraphQL;

package/src/formatting/OnTypeFormattingProvider.spec.ts

@@ -0,0 +1,74 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { DocumentOnTypeFormattingParams } from 'vscode-languageserver';
+import { Position } from 'vscode-languageserver-protocol';
+import { DocumentManager } from '../documents';
+import { OnTypeFormattingProvider } from './OnTypeFormattingProvider';
+
+const options: DocumentOnTypeFormattingParams['options'] = {
+  insertSpaces: true,
+  tabSize: 2,
+};
+
+describe('Module: OnTypeFormattingProvider', () => {
+  let documentManager: DocumentManager;
+  let onTypeFormattingProvider: OnTypeFormattingProvider;
+
+  beforeEach(() => {
+    documentManager = new DocumentManager();
+    onTypeFormattingProvider = new OnTypeFormattingProvider(documentManager);
+  });
+
+  it('should return null for non-existent documents', async () => {
+    const params: DocumentOnTypeFormattingParams = {
+      textDocument: { uri: 'file:///path/to/non-existent-document.liquid' },
+      position: Position.create(0, 0),
+      ch: ' ',
+      options,
+    };
+
+    const result = await onTypeFormattingProvider.onTypeFormatting(params);
+    expect(result).toBeNull();
+  });
+
+  it('should return null if character is space and cursor position is less than or equal to 2', async () => {
+    const params: DocumentOnTypeFormattingParams = {
+      textDocument: { uri: 'file:///path/to/document.liquid' },
+      position: Position.create(0, 1),
+      ch: ' ',
+      options,
+    };
+
+    documentManager.open(params.textDocument.uri, 'Sample text content', 1);
+
+    const result = await onTypeFormattingProvider.onTypeFormatting(params);
+    expect(result).toBeNull();
+  });
+
+  it('should return null if character is not space and cursor position is less than or equal to 1', async () => {
+    const params: DocumentOnTypeFormattingParams = {
+      textDocument: { uri: 'file:///path/to/document.liquid' },
+      position: Position.create(0, 0),
+      ch: 'a',
+      options,
+    };
+
+    documentManager.open(params.textDocument.uri, 'Sample text content', 1);
+
+    const result = await onTypeFormattingProvider.onTypeFormatting(params);
+    expect(result).toBeNull();
+  });
+
+  it('should return null for characters not matching any case', async () => {
+    const params: DocumentOnTypeFormattingParams = {
+      textDocument: { uri: 'file:///path/to/document.liquid' },
+      position: Position.create(0, 3),
+      ch: 'a',
+      options,
+    };
+
+    documentManager.open(params.textDocument.uri, 'Sample text content', 1);
+
+    const result = await onTypeFormattingProvider.onTypeFormatting(params);
+    expect(result).toBeNull();
+  });
+});

package/src/formatting/OnTypeFormattingProvider.ts

@@ -0,0 +1,26 @@
+import { DocumentOnTypeFormattingParams } from 'vscode-languageserver';
+import { DocumentManager } from '../documents';
+import { BracketsAutoclosingOnTypeFormattingProvider } from './providers/BracketsAutoclosingOnTypeFormattingProvider';
+import { HtmlElementAutoclosingOnTypeFormattingProvider } from './providers/HtmlElementAutoclosingOnTypeFormattingProvider';
+import { BaseOnTypeFormattingProvider, SetCursorPosition } from './types';
+
+export class OnTypeFormattingProvider {
+  private providers: BaseOnTypeFormattingProvider[];
+
+  constructor(
+    public documentManager: DocumentManager,
+    public setCursorPosition: SetCursorPosition = async () => {},
+  ) {
+    this.providers = [
+      new BracketsAutoclosingOnTypeFormattingProvider(),
+      new HtmlElementAutoclosingOnTypeFormattingProvider(setCursorPosition),
+    ];
+  }
+
+  async onTypeFormatting(params: DocumentOnTypeFormattingParams) {
+    const document = this.documentManager.get(params.textDocument.uri);
+    if (!document) return null;
+    const results = this.providers.map((provider) => provider.onTypeFormatting(document, params));
+    return results.find((result) => result !== null) ?? null;
+  }
+}

package/src/formatting/index.ts

@@ -0,0 +1 @@
+export { OnTypeFormattingProvider } from './OnTypeFormattingProvider';