Use snippets for block completion (#302)

packages/shared/src/string.spec.ts

@@ -6,6 +6,7 @@ import {
   isPascalCase,
   isCamelCase,
   isKebabCase,
+  trimIndent,
 } from './string'
 
 describe('isString', () => {
@@ -141,3 +142,31 @@ describe('isKebabCase', () => {
     expect(isKebabCase('_Prefix')).toBe(false)
   })
 })
+
+describe('trimIndent', () => {
+  test('check', () => {
+    expect(trimIndent('  foo  ')).toBe('foo  \n')
+
+    expect(
+      trimIndent(`
+      foo
+        bar
+      baz
+    `),
+    ).toBe('foo\n  bar\nbaz\n')
+
+    expect(
+      trimIndent(`
+        foo
+        bar  
+    `),
+    ).toBe('foo\nbar  \n')
+
+    expect(
+      trimIndent(`foo
+        bar
+      baz
+    `),
+    ).toBe('foo\n  bar\nbaz\n')
+  })
+})

packages/shared/src/string.ts

@@ -1,3 +1,5 @@
+import { first } from './array'
+
 export function isString(value: any): value is string {
   return typeof value === 'string'
 }
@@ -65,3 +67,26 @@ export function ucfirst(str: string): string {
 export function lcfirst(str: string): string {
   return str.slice(0, 1).toLowerCase() + str.slice(1)
 }
+
+export function trimIndent(content: string): string {
+  const lines = content
+    .trimStart()
+    .replace(/\n\s*$/, '')
+    .split('\n')
+
+  const indent = lines.slice(1).reduce((min, line) => {
+    const match = line.match(/^\s+/)
+    const len = match?.[0] != null ? match[0].length : 0
+    return Math.min(min, len)
+  }, Infinity)
+  if (lines.length <= 1) return first(lines) + '\n'
+  return (
+    first(lines) +
+    '\n' +
+    lines
+      .slice(1)
+      .map((line) => line.slice(indent))
+      .join('\n') +
+    '\n'
+  )
+}

packages/transforms/test/tsTransformScriptSetup.spec.ts

@@ -1,5 +1,6 @@
 import { transformScriptSetup } from '../src/tsTransformScriptSetup'
 import * as typescript from 'typescript/lib/tsserverlibrary'
+import { trimIndent } from '@vuedx/shared'
 
 expect.addSnapshotSerializer({
   test: () => true,
@@ -180,17 +181,3 @@ describe(transformScriptSetup, () => {
     ])
   })
 })
-
-function trimIndent(str: string) {
-  const lines = str.trim().split('\n')
-  const size = lines
-    .slice(1)
-    .reduce(
-      (size, line) => Math.min(size, /^[ ]*/.exec(line)?.[0].length ?? 0),
-      Infinity,
-    )
-
-  return [lines[0], ...lines.slice(1).map((line) => line.slice(size))].join(
-    '\n',
-  )
-}

packages/vue-language-server/src/fs.node.ts

@@ -1,6 +1,11 @@
-import { FileSystemProvider, FileType } from '@vuedx/vue-languageservice'
+import {
+  FilesystemHost,
+  FileSystemProvider,
+  FileType,
+} from '@vuedx/vue-languageservice'
+import FS from 'node:fs'
 import { readdir, stat } from 'node:fs/promises'
-import { posix } from 'node:path'
+import { extname, posix } from 'node:path'
 
 export function createFileSystemProvider(): FileSystemProvider {
   return {
@@ -50,3 +55,42 @@ export function createFileSystemProvider(): FileSystemProvider {
     },
   }
 }
+export function createFilesystemHost(): FilesystemHost {
+  return {
+    fileExists(path) {
+      return FS.existsSync(path)
+    },
+
+    readFile(path) {
+      return FS.readFileSync(path, 'utf-8')
+    },
+
+    watchFile(_path, _callback) {
+      return {
+        close() {
+          // TODO
+        },
+      }
+    },
+
+    watchDirectory(_path, _callback) {
+      return {
+        close() {
+          // TODO
+        },
+      }
+    },
+
+    readDirectory(dir, extensions) {
+      return FS.readdirSync(dir, {
+        withFileTypes: true,
+        encoding: 'utf8',
+      })
+        .filter(
+          (dirent) =>
+            dirent.isFile() && extensions.includes(extname(dirent.name)),
+        )
+        .map((dirent) => dirent.name)
+    },
+  }
+}

packages/vue-language-server/src/index.ts

@@ -8,7 +8,7 @@ import {
   TextDocuments,
   TextDocumentSyncKind,
 } from 'vscode-languageserver/node'
-import { createFileSystemProvider } from './fs.node'
+import { createFilesystemHost, createFileSystemProvider } from './fs.node'
 import { createVueLanguageService } from './service'
 
 const connection = createConnection(ProposedFeatures.all)
@@ -27,6 +27,7 @@ connection.onInitialize((client) => {
 
   const service = createVueLanguageService(
     documents,
+    createFilesystemHost(),
     createFileSystemProvider(),
     client.capabilities.general?.markdown != null,
   )

packages/vue-language-server/src/service.ts

@@ -7,11 +7,14 @@ import {
   LanguageModeVueHTML,
   VueLanguageService,
   VueTextDocument,
+  FilesystemHost,
+  VueProjectService,
 } from '@vuedx/vue-languageservice'
 import { TextDocuments } from 'vscode-languageserver'
 
 export function createVueLanguageService(
   documents: TextDocuments<VueTextDocument>,
+  host: FilesystemHost,
   fs: FileSystemProvider,
   supportsMarkdown: boolean = true,
 ): VueLanguageService {
@@ -48,7 +51,9 @@ export function createVueLanguageService(
     })
   })
 
-  service.registerLanguageMode(new LanguageModeVue(fs, supportsMarkdown))
+  service.registerLanguageMode(
+    new LanguageModeVue(new VueProjectService(host), fs, supportsMarkdown),
+  )
 
   return service
 }

packages/vue-languageservice/package.json

@@ -30,6 +30,7 @@
     "@vuedx/shared": "workspace:*",
     "@vuedx/template-ast-types": "workspace:*",
     "@vuedx/compiler-sfc": "workspace:*",
+    "@vuedx/projectconfig": "workspace:*",
     "vscode-languageserver-protocol": "^3.17.2",
     "vscode-languageserver-types": "^3.17.2",
     "vscode-languageserver-textdocument": "^1.0.7",

packages/vue-languageservice/src/VueProjectService.ts

@@ -0,0 +1,55 @@
+import { FilesystemHost, VueProject } from '@vuedx/projectconfig'
+import { cache } from '@vuedx/shared'
+import Path from 'path'
+
+export type { FilesystemHost, VueProject }
+export class VueProjectService {
+  #projects: Map<string, VueProject> = new Map()
+  #inferred: VueProject | undefined
+
+  constructor(private readonly fileSystemHost: FilesystemHost) {}
+
+  @cache()
+  public getProject(fileName: string): VueProject {
+    const find = findConfigFile.bind(
+      null,
+      (id) => this.fileSystemHost.fileExists(id),
+      fileName,
+    )
+
+    const configOrPackageFile = find('vueconfig.json') ?? find('package.json')
+    if (configOrPackageFile == null) {
+      if (this.#inferred == null) {
+        this.#inferred = VueProject.create(this.fileSystemHost, '/')
+      }
+
+      return this.#inferred
+    }
+
+    let project = this.#projects.get(configOrPackageFile)
+    if (project != null) return project
+
+    project = VueProject.create(
+      this.fileSystemHost,
+      Path.dirname(configOrPackageFile),
+    )
+
+    this.#projects.set(configOrPackageFile, project)
+
+    return project
+  }
+}
+
+function findConfigFile(
+  exists: (path: string) => boolean,
+  fileName: string,
+  configName: string,
+): string | undefined {
+  const dir = Path.dirname(fileName)
+  if (exists(Path.join(dir, configName))) return dir
+
+  const parent = Path.posix.dirname(dir)
+  if (parent === dir) return
+
+  return findConfigFile(exists, parent, configName)
+}

packages/vue-languageservice/src/VueTextDocument.spec.ts

@@ -1,4 +1,5 @@
 import { VueTextDocument } from './VueTextDocument'
+import { trimIndent } from '@vuedx/shared'
 
 describe(VueTextDocument, () => {
   it('should return the correct block', () => {
@@ -120,21 +121,3 @@ describe(VueTextDocument, () => {
     `)
   })
 })
-
-function trimIndent(content: string): string {
-  const lines = content.trim().split('\n')
-  const indent = lines.slice(1).reduce((min, line) => {
-    const match = line.match(/^\s+/)
-    const len = match?.[0] != null ? match[0].length : 0
-    return Math.min(min, len)
-  }, Infinity)
-  return (
-    lines[0] +
-    '\n' +
-    lines
-      .slice(1)
-      .map((line) => line.slice(indent))
-      .join('\n') +
-    '\n'
-  )
-}

packages/vue-languageservice/src/index.ts

@@ -13,3 +13,5 @@ export {
 export { LanguageModeVue, LanguageModeVueHTML } from './modes/LanguageModeHTML'
 export { VueLanguageService } from './VueLanguageService'
 export { VueTextDocument } from './VueTextDocument'
+export { VueProjectService } from './VueProjectService'
+export type { FilesystemHost, VueProject } from './VueProjectService'