@lvce-editor/shared-process 0.0.2 → 0.0.8

package/test/ExtensionHostDiagnostic.test.js

@@ -1,23 +0,0 @@
-import * as ExtensionHostDiagnostic from '../src/parts/ExtensionHost/ExtensionHostDiagnostic.js'
-
-test('executeDiagnosticProvider - empty', async () => {
-  const fakeExtensionHost = {
-    invoke() {
-      return []
-    },
-  }
-  expect(
-    await ExtensionHostDiagnostic.executeDiagnosticProvider(fakeExtensionHost)
-  ).toEqual([])
-})
-
-test('executeDiagnosticProvider - error', async () => {
-  const fakeExtensionHost = {
-    invoke() {
-      throw new TypeError('x is not a function')
-    },
-  }
-  await expect(
-    ExtensionHostDiagnostic.executeDiagnosticProvider(fakeExtensionHost, 0)
-  ).rejects.toThrowError(new TypeError('x is not a function'))
-})

package/test/ExtensionHostFileSystem.test.js

@@ -1,91 +0,0 @@
-import * as ExtensionHostFileSystem from '../src/parts/ExtensionHost/ExtensionHostFileSystem.js'
-
-test('readFile', async () => {
-  const fakeExtensionHost = {
-    async invoke() {
-      return ''
-    },
-  }
-  expect(
-    await ExtensionHostFileSystem.readFile(
-      fakeExtensionHost,
-      '/test',
-      '/test/file.txt'
-    )
-  ).toBe('')
-})
-
-test('readFile - error', async () => {
-  const fakeExtensionHost = {
-    async invoke() {
-      throw new TypeError('x is not a function')
-    },
-  }
-  await expect(
-    ExtensionHostFileSystem.readFile(
-      fakeExtensionHost,
-      'test',
-      '/test/file.txt'
-    )
-  ).rejects.toThrowError(new TypeError('x is not a function'))
-})
-
-test('writeFile', async () => {
-  const fakeExtensionHost = {
-    async invoke() {},
-  }
-  expect(
-    await ExtensionHostFileSystem.writeFile(
-      fakeExtensionHost,
-      '/test',
-      '/test/file.txt',
-      ''
-    )
-  ).toBeUndefined()
-})
-
-test('writeFile - error', async () => {
-  const fakeExtensionHost = {
-    async invoke() {
-      throw new TypeError('x is not a function')
-    },
-  }
-  await expect(
-    ExtensionHostFileSystem.writeFile(
-      fakeExtensionHost,
-      'test',
-      '/test/file.txt',
-      ''
-    )
-  ).rejects.toThrowError(new TypeError('x is not a function'))
-})
-
-test('readDirWithFileTypes', async () => {
-  const fakeExtensionHost = {
-    async invoke() {
-      return []
-    },
-  }
-  expect(
-    await ExtensionHostFileSystem.readDirWithFileTypes(
-      fakeExtensionHost,
-      'test',
-      '/test'
-    )
-  ).toEqual([])
-})
-
-test('readDirWithFileTypes - error', async () => {
-  const fakeExtensionHost = {
-    async invoke() {
-      throw new TypeError('x is not a function')
-    },
-  }
-  await expect(
-    ExtensionHostFileSystem.readDirWithFileTypes(
-      fakeExtensionHost,
-      'test',
-      '/test'
-    )
-  ).rejects.toThrowError(new TypeError('x is not a function'))
-})

package/test/ExtensionHostFormatting.test.js

@@ -1,27 +0,0 @@
-import * as ExtensionHostFormatting from '../src/parts/ExtensionHost/ExtensionHostFormatting.js'
-
-test('executeFormattingProvider', async () => {
-  const fakeExtensionHost = {
-    invoke() {
-      return ''
-    },
-  }
-  expect(
-    await ExtensionHostFormatting.format(
-      fakeExtensionHost,
-      '/test/file.txt',
-      ''
-    )
-  ).toEqual('')
-})
-
-test('executeFormattingProvider - error', async () => {
-  const fakeExtensionHost = {
-    invoke() {
-      throw new TypeError('x is not a function')
-    },
-  }
-  await expect(
-    ExtensionHostFormatting.format(fakeExtensionHost, '/test/file.txt', '')
-  ).rejects.toThrowError(new TypeError('x is not a function'))
-})

package/test/ExtensionHostIconTheme.test.js

@@ -1,73 +0,0 @@
-import { mkdtemp, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import * as ExtensionHostIconTheme from '../src/parts/ExtensionHost/ExtensionHostIconTheme.js'
-import * as ExtensionManagement from '../src/parts/ExtensionManagement/ExtensionManagement.js'
-
-const getTmpDir = () => {
-  return mkdtemp(join(tmpdir(), 'foo-'))
-}
-
-test('getIconTheme - not found', async () => {
-  ExtensionManagement.state.getExtensions = async () => {
-    return []
-  }
-  await expect(
-    ExtensionHostIconTheme.getIconTheme('test-theme')
-  ).rejects.toThrowError(
-    'Icon theme "test-theme" not found in extensions folder'
-  )
-})
-
-test('getIconTheme - wrong/invalid path', async () => {
-  const tmpDir = await getTmpDir()
-  ExtensionManagement.state.getExtensions = async () => {
-    return [
-      {
-        status: 'fulfilled',
-        id: 'builtin.theme-test',
-        iconThemes: [
-          {
-            id: 'test',
-            label: 'Test',
-            path: 'icon-theme.json',
-          },
-        ],
-        path: tmpDir,
-      },
-    ]
-  }
-  const iconThemeJsonPath = join(tmpDir, 'icon-theme.json')
-  await expect(
-    ExtensionHostIconTheme.getIconTheme('test')
-  ).rejects.toThrowError(
-    `Failed to load icon theme "test": ENOENT: no such file or directory, open '${iconThemeJsonPath}'`
-  )
-})
-
-test('getIconTheme - invalid json', async () => {
-  const tmpDir = await getTmpDir()
-  ExtensionManagement.state.getExtensions = async () => {
-    return [
-      {
-        status: 'fulfilled',
-        id: 'builtin.icon-theme-test',
-        iconThemes: [
-          {
-            id: 'test',
-            label: 'Test',
-            path: 'icon-theme.json',
-          },
-        ],
-        path: tmpDir,
-      },
-    ]
-  }
-  const iconThemeJsonPath = join(tmpDir, 'icon-theme.json')
-  await writeFile(iconThemeJsonPath, '{ 2 }')
-  await expect(
-    ExtensionHostIconTheme.getIconTheme('test')
-  ).rejects.toThrowError(
-    'Failed to load icon theme "test": Unexpected number in JSON at position 2 while parsing \'{ 2 }\''
-  )
-})

package/test/ExtensionHostLanguages.test.js

@@ -1,212 +0,0 @@
-import { mkdtemp, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { pathToFileURL } from 'node:url'
-import * as ExtensionHostLanguages from '../src/parts/ExtensionHost/ExtensionHostLanguages.js'
-import * as ExtensionManagement from '../src/parts/ExtensionManagement/ExtensionManagement.js'
-
-const getTmpDir = () => {
-  return mkdtemp(join(tmpdir(), 'foo-'))
-}
-
-test('getLanguages', async () => {
-  const tmpDir = await getTmpDir()
-  ExtensionManagement.state.getExtensions = async () => {
-    return [
-      {
-        status: 'fulfilled',
-        id: 'builtin.plaintext',
-        languages: [
-          {
-            id: 'plaintext',
-            label: 'Plaintext',
-            tokenize: 'src/tokenizePlainText.js',
-          },
-        ],
-        path: tmpDir,
-      },
-    ]
-  }
-  expect(await ExtensionHostLanguages.getLanguages()).toEqual([
-    {
-      id: 'plaintext',
-      label: 'Plaintext',
-      tokenize: `/remote/${pathToFileURL(
-        join(tmpDir, 'src/tokenizePlainText.js')
-      )
-        .toString()
-        .slice(8)}`,
-    },
-  ])
-})
-
-// TODO
-test('getLanguages - error - property languages is not of type array', async () => {
-  const tmpDir = await getTmpDir()
-  ExtensionManagement.state.getExtensions = async () => {
-    return [
-      {
-        status: 'fulfilled',
-        id: 'builtin.plaintext',
-        languages: {},
-        path: tmpDir,
-      },
-    ]
-  }
-  // TODO should handle error gracefully
-  await expect(ExtensionHostLanguages.getLanguages()).rejects.toThrowError(
-    new TypeError('extension.languages.map is not a function')
-  )
-})
-
-test('getLanguages - language without tokenize property', async () => {
-  const tmpDir = await getTmpDir()
-  ExtensionManagement.state.getExtensions = async () => {
-    return [
-      {
-        status: 'fulfilled',
-        id: 'builtin.icon-theme-test',
-        languages: [
-          {
-            id: 'plaintext',
-            label: 'Plaintext',
-          },
-        ],
-        path: tmpDir,
-      },
-    ]
-  }
-  expect(await ExtensionHostLanguages.getLanguages()).toEqual([
-    {
-      id: 'plaintext',
-      label: 'Plaintext',
-    },
-  ])
-})
-
-test('getLanguages - error - property tokenize is of type array', async () => {
-  const tmpDir = await getTmpDir()
-  ExtensionManagement.state.getExtensions = async () => {
-    return [
-      {
-        status: 'fulfilled',
-        id: 'builtin.test',
-        languages: [
-          {
-            id: 'python',
-            extensions: ['.py'],
-            configuration: './languageConfiguration.json',
-            tokenize: ['src/tokenizePython.js'],
-          },
-        ],
-        path: tmpDir,
-      },
-    ]
-  }
-  expect(await ExtensionHostLanguages.getLanguages()).toEqual([
-    {
-      configuration: './languageConfiguration.json',
-      extensions: ['.py'],
-      id: 'python',
-      tokenize: '',
-    },
-  ])
-})
-
-test('getLanguageConfiguration', async () => {
-  const tmpDir = await getTmpDir()
-  await writeFile(
-    join(tmpDir, 'languageConfiguration.json'),
-    `{
-    "comments": {
-      "lineComment": "//",
-      "blockComment": ["/*", "*/"]
-    }
-}
-`
-  )
-
-  ExtensionManagement.state.getExtensions = async () => {
-    return [
-      {
-        status: 'fulfilled',
-        id: 'builtin.javascript',
-        languages: [
-          {
-            id: 'javascript',
-            extensions: ['.js'],
-            tokenize: 'src/tokenizeJavaScript.js',
-            configuration: './languageConfiguration.json',
-          },
-        ],
-        path: tmpDir,
-      },
-    ]
-  }
-  expect(
-    await ExtensionHostLanguages.getLanguageConfiguration('javascript')
-  ).toEqual({
-    comments: {
-      blockComment: ['/*', '*/'],
-      lineComment: '//',
-    },
-  })
-})
-test('getLanguageConfiguration - error - language configuration not found', async () => {
-  const tmpDir = await getTmpDir()
-  ExtensionManagement.state.getExtensions = async () => {
-    return [
-      {
-        status: 'fulfilled',
-        id: 'builtin.javascript',
-        languages: [
-          {
-            id: 'javascript',
-            extensions: ['.js'],
-            tokenize: 'src/tokenizeJavaScript.js',
-            configuration: './languageConfiguration.json',
-          },
-        ],
-        path: tmpDir,
-      },
-    ]
-  }
-  const languageConfigurationPath = join(tmpDir, 'languageConfiguration.json')
-  await expect(
-    ExtensionHostLanguages.getLanguageConfiguration('javascript')
-  ).rejects.toThrowError(
-    new Error(
-      `Failed to load language configuration for javascript: ENOENT: no such file or directory, open '${languageConfigurationPath}'`
-    )
-  )
-})
-
-test('getLanguageConfiguration - error - language configuration has invalid json', async () => {
-  const tmpDir = await getTmpDir()
-  await writeFile(join(tmpDir, 'languageConfiguration.json'), '{')
-  ExtensionManagement.state.getExtensions = async () => {
-    return [
-      {
-        status: 'fulfilled',
-        id: 'builtin.javascript',
-        languages: [
-          {
-            id: 'javascript',
-            extensions: ['.js'],
-            tokenize: 'src/tokenizeJavaScript.js',
-            configuration: './languageConfiguration.json',
-          },
-        ],
-        path: tmpDir,
-      },
-    ]
-  }
-  // TODO should display path as well
-  await expect(
-    ExtensionHostLanguages.getLanguageConfiguration('javascript')
-  ).rejects.toThrowError(
-    new Error(
-      'Failed to load language configuration for javascript: Unexpected end of JSON input while parsing "{"'
-    )
-  )
-})

package/test/ExtensionHostOutput.test.js

@@ -1,23 +0,0 @@
-import * as ExtensionHostOutput from '../src/parts/ExtensionHost/ExtensionHostOutput.js'
-
-test('getOutputChannels - empty', async () => {
-  const fakeExtensionHost = {
-    async invoke() {
-      return []
-    },
-  }
-  expect(
-    await ExtensionHostOutput.getOutputChannels(fakeExtensionHost)
-  ).toEqual([])
-})
-
-test('getOutputChannels - error', async () => {
-  const fakeExtensionHost = {
-    async invoke() {
-      throw new TypeError('x is not a function')
-    },
-  }
-  await expect(
-    ExtensionHostOutput.getOutputChannels(fakeExtensionHost)
-  ).rejects.toThrowError(new TypeError('x is not a function'))
-})

package/test/ExtensionHostRename.test.js

@@ -1,59 +0,0 @@
-import * as ExtensionHostRename from '../src/parts/ExtensionHost/ExtensionHostRename.js'
-
-test('executePrepareRename', async () => {
-  const fakeExtensionHost = {
-    invoke() {
-      return {
-        canRename: true,
-      }
-    },
-  }
-  expect(
-    await ExtensionHostRename.executePrepareRename(fakeExtensionHost, 0, 0)
-  ).toEqual({
-    canRename: true,
-  })
-})
-
-test('executePrepareRename - error', async () => {
-  const fakeExtensionHost = {
-    invoke() {
-      throw new TypeError('x is not a function')
-    },
-  }
-  await expect(
-    ExtensionHostRename.executePrepareRename(fakeExtensionHost, 0, 0)
-  ).rejects.toThrowError(new TypeError('x is not a function'))
-})
-
-test('executeRename', async () => {
-  const fakeExtensionHost = {
-    invoke() {
-      return [
-        {
-          file: '/test/file.txt',
-          edits: [],
-        },
-      ]
-    },
-  }
-  expect(
-    await ExtensionHostRename.executeRename(fakeExtensionHost, 0, 0, '')
-  ).toEqual([
-    {
-      file: '/test/file.txt',
-      edits: [],
-    },
-  ])
-})
-
-test('executeRename - error', async () => {
-  const fakeExtensionHost = {
-    invoke() {
-      throw new TypeError('x is not a function')
-    },
-  }
-  await expect(
-    ExtensionHostRename.executeRename(fakeExtensionHost, 0, 0, '')
-  ).rejects.toThrowError(new TypeError('x is not a function'))
-})

package/test/ExtensionHostSemanticTokens.test.js

@@ -1,26 +0,0 @@
-import * as ExtensionHostSemanticTokens from '../src/parts/ExtensionHost/ExtensionHostSemanticTokens.js'
-
-test('executeSemanticTokenProvider', async () => {
-  const fakeExtensionHost = {
-    invoke() {
-      return [1, 2, 3, 4, 5]
-    },
-  }
-  expect(
-    await ExtensionHostSemanticTokens.executeSemanticTokenProvider(
-      fakeExtensionHost,
-      0
-    )
-  ).toEqual([1, 2, 3, 4, 5])
-})
-
-test('executeCompletionProvider - error', async () => {
-  const fakeExtensionHost = {
-    invoke() {
-      throw new TypeError('x is not a function')
-    },
-  }
-  await expect(
-    ExtensionHostSemanticTokens.executeSemanticTokenProvider(fakeExtensionHost)
-  ).rejects.toThrowError(new TypeError('x is not a function'))
-})

package/test/ExtensionHostTabCompletion.test.js

@@ -1,35 +0,0 @@
-import * as ExtensionHostTabCompletion from '../src/parts/ExtensionHost/ExtensionHostTabCompletion.js'
-
-test('executeTabCompletionProvider', async () => {
-  const fakeExtensionHost = {
-    invoke() {
-      return {
-        inserted: '<div></div>',
-        deleted: 0,
-        type: /* Snippet */ 2,
-      }
-    },
-  }
-  expect(
-    await ExtensionHostTabCompletion.executeTabCompletionProvider(
-      fakeExtensionHost,
-      0,
-      0
-    )
-  ).toEqual({
-    inserted: '<div></div>',
-    deleted: 0,
-    type: /* Snippet */ 2,
-  })
-})
-
-test('executeTabCompletionProvider - error', async () => {
-  const fakeExtensionHost = {
-    invoke() {
-      throw new TypeError('x is not a function')
-    },
-  }
-  await expect(
-    ExtensionHostTabCompletion.executeTabCompletionProvider(fakeExtensionHost)
-  ).rejects.toThrowError(new TypeError('x is not a function'))
-})

package/test/ExtensionHostTextDocument.test.js

@@ -1,61 +0,0 @@
-import * as ExtensionHostTextDocument from '../src/parts/ExtensionHost/ExtensionHostTextDocument.js'
-
-test('textDocumentSyncInitial', async () => {
-  const fakeExtensionHost = {
-    invoke() {},
-  }
-  expect(
-    await ExtensionHostTextDocument.textDocumentSyncInitial(
-      fakeExtensionHost,
-      '/test/file.txt',
-      0,
-      '',
-      ''
-    )
-  ).toEqual(undefined)
-})
-
-test('textDocumentSyncInitial - error', async () => {
-  const fakeExtensionHost = {
-    async invoke() {
-      throw new TypeError('x is not a function')
-    },
-  }
-  await expect(
-    ExtensionHostTextDocument.textDocumentSyncInitial(
-      fakeExtensionHost,
-      '/test/file.txt',
-      0,
-      '',
-      ''
-    )
-  ).rejects.toThrowError(new TypeError('x is not a function'))
-})
-
-test('textDocumentSyncIncremental', async () => {
-  const fakeExtensionHost = {
-    invoke() {},
-  }
-  expect(
-    await ExtensionHostTextDocument.textDocumentSyncIncremental(
-      fakeExtensionHost,
-      0,
-      []
-    )
-  ).toEqual(undefined)
-})
-
-test('textDocumentSyncInitial - error', async () => {
-  const fakeExtensionHost = {
-    async invoke() {
-      throw new TypeError('x is not a function')
-    },
-  }
-  await expect(
-    ExtensionHostTextDocument.textDocumentSyncIncremental(
-      fakeExtensionHost,
-      0,
-      []
-    )
-  ).rejects.toThrowError(new TypeError('x is not a function'))
-})

package/test/ExtensionHostTypeDefinition.test.js

@@ -1,35 +0,0 @@
-import * as ExtensionHostTypeDefinition from '../src/parts/ExtensionHost/ExtensionHostTypeDefinition.js'
-
-test('executeTypeDefinitionProvider', async () => {
-  const fakeExtensionHost = {
-    invoke() {
-      return {
-        uri: '/test/file.txt',
-        startOffset: 0,
-        endOffset: 0,
-      }
-    },
-  }
-  expect(
-    await ExtensionHostTypeDefinition.executeTypeDefinitionProvider(
-      fakeExtensionHost,
-      0,
-      0
-    )
-  ).toEqual({
-    uri: '/test/file.txt',
-    startOffset: 0,
-    endOffset: 0,
-  })
-})
-
-test('executeTypeDefinitionProvider - error', async () => {
-  const fakeExtensionHost = {
-    invoke() {
-      throw new TypeError('x is not a function')
-    },
-  }
-  await expect(
-    ExtensionHostTypeDefinition.executeTypeDefinitionProvider(fakeExtensionHost)
-  ).rejects.toThrowError(new TypeError('x is not a function'))
-})

package/test/ExtensionHostWorkspace.test.js

@@ -1,21 +0,0 @@
-import * as ExtensionHostWorkspace from '../src/parts/ExtensionHost/ExtensionHostWorkspace.js'
-
-test('setWorkspacePath', async () => {
-  const fakeExtensionHost = {
-    invoke() {},
-  }
-  expect(
-    await ExtensionHostWorkspace.setWorkspacePath(fakeExtensionHost, '/test')
-  ).toEqual(undefined)
-})
-
-test('setWorkspacePath - error', async () => {
-  const fakeExtensionHost = {
-    async invoke() {
-      throw new TypeError('x is not a function')
-    },
-  }
-  await expect(
-    ExtensionHostWorkspace.setWorkspacePath(fakeExtensionHost, '/test')
-  ).rejects.toThrowError(new TypeError('x is not a function'))
-})