realising we need declare global

Author: lerouxb

package-lock.json

@@ -54,6 +54,7 @@
     "@types/mocha": "^9.1.1",
     "@types/sinon-chai": "^3.2.5",
     "chai": "^4.3.6",
+    "debug": "^4.3.6",
     "depcheck": "^1.4.1",
     "eslint": "^7.25.0",
     "gen-esm-wrapper": "^1.1.1",

packages/ts-autocomplete/package.json

@@ -1,6 +1,21 @@
 import Autocompleter from './index';
 import { expect } from 'chai';
 
+const FOO_TS = `
+
+export type Foo = {
+    a: string,
+    bb: (p1: number) => void
+};
+
+export type Params = { param1: string, param2: string };
+
+declare global {
+  declare var foo: Foo;
+  export function bar(params: Params): void {};
+}
+`;
+
 describe('Autocompleter', function () {
   let autoCompleter: Autocompleter;
 
@@ -12,45 +27,52 @@ describe('Autocompleter', function () {
     expect(autoCompleter.autocomplete('foo')).to.deep.equal([]);
     expect(autoCompleter.autocomplete('foo', 0)).to.deep.equal([]);
     expect(autoCompleter.autocomplete('foo', 1)).to.deep.equal([]);
+    expect(autoCompleter.autocomplete('foo.')).to.deep.equal([]);
   });
 
-  it('returns completions when it knows of some code', function () {
+  it('returns completions for members of global variables', function () {
     autoCompleter.updateCode({
-      'foo.ts': `
-export type Foo = {
-    a: string,
-    bb: function (p1: number) {}
-};
-
-  declare global {
-    declare var foo: Foo;
-  }
-    `,
+      '/foo.d.ts': FOO_TS,
     });
 
     expect(autoCompleter.autocomplete('foo')).to.deep.equal([]);
     expect(autoCompleter.autocomplete('foo.')).to.deep.equal([
       { kind: 'property', name: 'a', type: 'string' },
-      { kind: 'property', name: 'bb', type: 'function (p1: number)' },
+      { kind: 'property', name: 'bb', type: '(p1: number) => void' },
     ]);
 
     expect(autoCompleter.autocomplete('foo.', 0)).to.deep.equal([]);
     expect(autoCompleter.autocomplete('foo.', 1)).to.deep.equal([]);
     expect(autoCompleter.autocomplete('foo.', 2)).to.deep.equal([]);
     expect(autoCompleter.autocomplete('foo.', 3)).to.deep.equal([]);
 
-    // TODO: is this expected?
-    expect(autoCompleter.autocomplete('fo')).to.deep.equal([]);
-
-    // TODO: is this expected?
     expect(autoCompleter.autocomplete('foo.b')).to.deep.equal([
       { kind: 'property', name: 'a', type: 'string' },
-      { kind: 'property', name: 'bb', type: 'function (p1: number)' },
+      { kind: 'property', name: 'bb', type: '(p1: number) => void' },
     ]);
 
     expect(autoCompleter.autocomplete('foo.bar', 4)).to.deep.equal([
       { kind: 'property', name: 'a', type: 'string' },
-      { kind: 'property', name: 'bb', type: 'function (p1: number)' },
+      { kind: 'property', name: 'bb', type: '(p1: number) => void' },
+    ]);
+  });
+
+  it('returns completions for the fields of object function parameters', function () {
+    autoCompleter.updateCode({
+      '/foo.d.ts': FOO_TS,
+    });
+
+    expect(autoCompleter.autocomplete('bar({ par')).to.deep.equal([
+      {
+        kind: 'property',
+        name: 'param1',
+        type: 'string',
+      },
+      {
+        kind: 'property',
+        name: 'param2',
+        type: 'string',
+      },
     ]);
   });
 });

packages/ts-autocomplete/src/index.spec.ts

@@ -1,4 +1,9 @@
 import * as ts from 'typescript';
+import createDebug from 'debug';
+
+const debugLog = createDebug('ts-autocomplete:log');
+const debugTrace = createDebug('ts-autocomplete:trace');
+const debugError = createDebug('ts-autocomplete:error');
 
 type TypeFilename = string;
 
@@ -18,13 +23,17 @@ function getVirtualLanguageService(): [
   const updateCode = (newDef: Record<TypeFilename, string>): void => {
     for (const [key, value] of Object.entries(newDef)) {
       codeHolder[key] = value;
-      versions[key] = (versions[key] ?? 1) + 1;
+      versions[key] = (versions[key] ?? 0) + 1;
     }
   };
 
   const servicesHost: ts.LanguageServiceHost = {
-    getScriptFileNames: () => Object.keys(codeHolder),
-    getScriptVersion: (fileName) => (versions[fileName] ?? 1).toString(),
+    getScriptFileNames: () => {
+      return Object.keys(codeHolder);
+    },
+    getScriptVersion: (fileName) => {
+      return (versions[fileName] ?? 1).toString();
+    },
     getScriptSnapshot: (fileName) => {
       if (fileName in codeHolder) {
         return ts.ScriptSnapshot.fromString(codeHolder[fileName]);
@@ -35,8 +44,9 @@ function getVirtualLanguageService(): [
     getCurrentDirectory: () => process.cwd(),
     getCompilationSettings: () => options,
     getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
-    fileExists: (fileName) =>
-      fileName in codeHolder || ts.sys.fileExists(fileName),
+    fileExists: (fileName) => {
+      return fileName in codeHolder || ts.sys.fileExists(fileName);
+    },
     readFile: (fileName) => {
       if (fileName in codeHolder) {
         return codeHolder[fileName];
@@ -46,6 +56,10 @@ function getVirtualLanguageService(): [
     readDirectory: (...args) => ts.sys.readDirectory(...args),
     directoryExists: (...args) => ts.sys.directoryExists(...args),
     getDirectories: (...args) => ts.sys.getDirectories(...args),
+
+    log: (...args) => debugLog(args),
+    trace: (...args) => debugTrace(args),
+    error: (...args) => debugError(args),
   };
 
   return [
@@ -62,6 +76,7 @@ type AutoCompletion = {
 
 function mapCompletions(completions: ts.CompletionInfo): AutoCompletion[] {
   return completions.entries.map((entry) => {
+    //console.log(entry.symbol?.getDeclarations());
     const declarations = entry.symbol?.getDeclarations();
     let type = 'any';
     if (declarations?.[0]) {
@@ -105,6 +120,18 @@ export default class Autocompleter {
 
     if (completions?.isMemberCompletion) {
       return mapCompletions(completions);
+    } else {
+      /*
+      // TOOD: trying to find examples of things that are not member completions..
+      if (completions) {
+        console.log(completions.entries?.length, 'entries');
+        if (completions.entries?.length > 100) {
+          completions.entries = [];// so I can see something
+        }
+        console.log(completions);
+        //console.log(completions?.entries.map((entry) =>  entry.name).filter((name) => name.includes('param')));
+      }
+        */
     }
 
     return [];